unnest archives with only one dir in it

Cargo.toml

@@ -4,5 +4,19 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+anyhow = "1.0.102"
+clap = { version = "4.5.60", features = ["derive"] }
+env_logger = "0.11.9"
+globset = "0.4.18"
+libloot = "0.29.0"
+log = "0.4.29"
 quick-xml = { version = "0.39.2", features = ["serde-types", "serialize"] }
 serde = { version = "1.0.228", features = ["derive"] }
+sevenz-rust2 = { version = "0.20.2" }
+thiserror = "2.0.18"
+toml = "1.0.3"
+unrar = "0.5.8"
+ureq = { version = "3.2.0", features = ["json"] }
+url = "2.5.8"
+walkdir = "2.5.0"
+zip = "8.2.0"

src/actions.rs

@@ -0,0 +1,11 @@
+mod activate;
+mod download;
+mod include;
+mod install;
+mod load_order;
+
+pub use activate::{ActivationError, activate_instance};
+pub use download::handle_nxm;
+pub use include::insert_mod_to_instance;
+pub use install::resolve_files_for_install;
+pub use load_order::{LoadOrderError, create_loadorder};

src/actions/activate.rs

@@ -0,0 +1,171 @@
+use log::{debug, trace};
+use thiserror::Error;
+
+use crate::types::{Game, Link, ModdedInstance, RootConfig};
+use std::collections::HashMap;
+use std::io::Write;
+use std::path::PathBuf;
+use std::{fs, io, os::unix, path::Path};
+
+/// Create the symlinks for a instance in a given directory
+pub fn activate_instance(
+    root_config: &RootConfig,
+    instance: &ModdedInstance,
+    target: impl AsRef<Path>,
+) -> Result<(), ActivationError> {
+    let game = root_config
+        .game_by_id(instance.game_id())
+        .ok_or(ActivationError::GameNotFound)?;
+
+    check_target_valid(&target)?;
+
+    let resolved_links = resolve_links(root_config, instance, &game)?;
+
+    resolved_links
+        .iter()
+        .try_for_each(|link| apply_link(link, &target))
+        .map_err(ActivationError::Linking)?;
+    create_plugins_txt(instance, target.as_ref()).map_err(ActivationError::PluginsTXT)?;
+
+    debug!("Finished activating instance");
+    Ok(())
+}
+
+fn resolve_links(
+    root_config: &RootConfig,
+    instance: &ModdedInstance,
+    game: &Game,
+) -> Result<Vec<Link>, ActivationError> {
+    let game_links = game
+        .export_links()
+        .map_err(ActivationError::ExportGameLinks)?;
+    let mod_links = resolve_link_for_instance(root_config, instance)?;
+    let overrides: Vec<Link> = instance.game_file_overrides().to_owned();
+
+    let mut map: HashMap<PathBuf, PathBuf> = HashMap::new();
+
+    for link in game_links.into_iter().chain(mod_links).chain(overrides) {
+        map.insert(link.dst().to_owned(), link.src().to_owned());
+    }
+
+    let final_links: Vec<Link> = map
+        .into_iter()
+        .map(|(dst, src)| Link::new(src, dst))
+        .collect();
+
+    Ok(final_links)
+}
+
+fn resolve_link_for_instance(
+    root_config: &RootConfig,
+    instance: &ModdedInstance,
+) -> Result<Vec<Link>, ActivationError> {
+    debug!("Resolving links for instance");
+
+    let mut links: Vec<Link> = Vec::new();
+
+    for installed_mod in instance.mods() {
+        let mod_config = root_config
+            .mod_by_id(installed_mod.mod_id())
+            .ok_or(ActivationError::ModNotFound)?;
+        let mod_source_root = root_config.mod_location().join(mod_config.path());
+
+        for link in installed_mod.files() {
+            let link_target = mod_source_root.join(link.src());
+            links.push(Link::new(link_target, link.dst()));
+        }
+    }
+
+    Ok(links)
+}
+
+fn apply_link(link: &Link, target: impl AsRef<Path>) -> Result<(), io::Error> {
+    let link_target = &link.src();
+    let link_name = target.as_ref().join(link.dst());
+
+    link_file(link_target, &link_name)
+}
+
+fn create_plugins_txt(
+    instance: &ModdedInstance,
+    target: impl AsRef<Path>,
+) -> Result<(), io::Error> {
+    debug!("Generating Plugins.txt");
+    let mut file = fs::File::create(target.as_ref().join("Plugins.txt"))?;
+
+    writeln!(file, "# Auto generated. DO NOT EDIT MANUALLY!")?;
+
+    for plugin in instance.load_order() {
+        writeln!(file, "*{}", plugin)?;
+    }
+
+    Ok(())
+}
+
+fn link_file(target: &Path, link_name: &Path) -> Result<(), io::Error> {
+    if let Some(parent) = link_name.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    create_symlink_for_file(target, link_name)?;
+    Ok(())
+}
+
+fn create_symlink_for_file(target: &Path, link_name: &Path) -> io::Result<()> {
+    trace!(
+        "Creating symlink at {} with target {}",
+        link_name.to_string_lossy(),
+        target.to_string_lossy()
+    );
+
+    #[cfg(unix)]
+    {
+        unix::fs::symlink(target, link_name)
+    }
+
+    #[cfg(windows)]
+    {
+        std::os::windows::fs::symlink_file(target, link_name)
+    }
+}
+
+fn check_target_valid(target: impl AsRef<Path>) -> Result<(), ActivationError> {
+    match fs::read_dir(&target) {
+        Ok(entries) => {
+            if entries.count() == 0 {
+                debug!(
+                    "Target {} is a valid target",
+                    &target.as_ref().to_string_lossy()
+                );
+                Ok(())
+            } else {
+                Err(ActivationError::TargetNotEmpty)
+            }
+        }
+        Err(e) => Err(ActivationError::TargetNotValid(e)),
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum ActivationError {
+    #[error("Could not find game in instance config")]
+    GameNotFound,
+
+    #[error("Could not find mod in instance config")]
+    ModNotFound,
+
+    #[error("The target is not empty")]
+    TargetNotEmpty,
+
+    #[error("The target is not valid")]
+    TargetNotValid(io::Error),
+
+    #[error("Failed to create symlink")]
+    Linking(io::Error),
+
+    #[error("Failed to create Plugins.txt")]
+    PluginsTXT(io::Error),
+
+    #[error("Failed to export files in game installation")]
+    ExportGameLinks(io::Error),
+}

src/actions/download.rs

@@ -0,0 +1,44 @@
+use anyhow::anyhow;
+use log::error;
+
+use crate::{
+    nexus::{NXMUrl, download_nxm},
+    types::{ModConfig, RootConfig},
+    unpacker::unpack,
+};
+
+/// Handles a nexus mod url. Downloads, unpacks and adds the mod to the config
+pub fn handle_nxm(root_config: &mut RootConfig, raw_url: &str) -> anyhow::Result<()> {
+    let Some(dl_location) = root_config.download_location() else {
+        return Err(anyhow!("No download location set"));
+    };
+
+    let Some(api_key) = root_config.nexus_api_key() else {
+        return Err(anyhow!("No API key provided"));
+    };
+
+    let Some(nxm_url) = NXMUrl::parse_url(raw_url) else {
+        return Err(anyhow!("Failed to parse URL"));
+    };
+
+    let (dl_file, mod_info) = download_nxm(api_key, &nxm_url, dl_location)?;
+
+    let mod_id = format!("{}-{}", mod_info.generate_id(), nxm_url.file);
+    if root_config.game_by_id(&mod_id).is_some() {
+        error!(
+            "Generated mod id already exists. Pleas install downloaded mod manually. Downloaded at {}",
+            &dl_file.to_string_lossy()
+        );
+        return Err(anyhow!("Mod with generated id already exists"));
+    }
+
+    let extract_to = root_config.mod_location().join(&mod_id);
+    unpack(dl_file, extract_to)?;
+
+    let file_id: u64 = nxm_url.file.parse()?;
+    let new_mod = ModConfig::from_mod_info(&mod_id, &mod_id, &mod_info, file_id);
+
+    root_config.add_mod(&new_mod);
+
+    Ok(())
+}

src/actions/include.rs

@@ -0,0 +1,70 @@
+use log::warn;
+use std::{collections::HashMap, path::PathBuf};
+
+use crate::{
+    file_conflict_solver::ConflictSolver,
+    types::{InstalledMod, ModConfig, ModFile, ModdedInstance},
+};
+
+pub fn insert_mod_to_instance(
+    instance: &mut ModdedInstance,
+    from_mod: &ModConfig,
+    files_to_add: &[ModFile],
+    priority: isize,
+) -> Option<FileConflict> {
+    let mut solver = ConflictSolver::new();
+
+    let mut installed_files: Vec<(ModFile, &InstalledMod)> = Vec::new();
+    for installed_mod in instance.mods() {
+        for link in installed_mod.files() {
+            let recreated_mod_file = ModFile::new(link.src(), link.dst(), 0);
+            installed_files.push((recreated_mod_file, installed_mod));
+        }
+    }
+
+    for (file, from_mod) in &installed_files {
+        if let Some(conflict) = solver.add_file(file, from_mod) {
+            warn!("File conflict on already added file: {:?}", conflict);
+        }
+    }
+
+    let new_mod = InstalledMod::new(from_mod.id(), priority);
+    for file in files_to_add {
+        if let Some(conflict) = solver.add_file(file, &new_mod) {
+            return Some(FileConflict {
+                lhs_mod_id: conflict.lhs_mod.mod_id().to_owned(),
+                rhs_mod_id: conflict.rhs_mod.mod_id().to_owned(),
+                path: conflict.rhs_file.dst().to_owned(),
+            });
+        }
+    }
+
+    let new_link_tree = solver.export_files();
+
+    let mut map: HashMap<String, InstalledMod> = HashMap::new();
+
+    for (file, from_mod) in new_link_tree {
+        match map.get_mut(from_mod.mod_id()) {
+            Some(existing) => {
+                existing.add_file(file);
+            }
+            None => {
+                let mut new_mod = InstalledMod::new(from_mod.mod_id(), from_mod.priority());
+                new_mod.add_file(file);
+                map.insert(new_mod.mod_id().to_owned(), new_mod);
+            }
+        }
+    }
+
+    for (_, installed_mod) in map {
+        instance.update_or_create_mod(&installed_mod);
+    }
+
+    None
+}
+
+pub struct FileConflict {
+    pub lhs_mod_id: String,
+    pub rhs_mod_id: String,
+    pub path: PathBuf,
+}

src/actions/install.rs

@@ -0,0 +1,166 @@
+use std::{
+    io,
+    path::{Path, PathBuf},
+};
+
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use log::{debug, trace};
+
+use crate::{
+    fomod, install_prompt,
+    mod_config_installer::run_fomod_installer,
+    types::{ModConfig, ModFile, ModdedInstance, RootConfig},
+    utils::{resolve_case_insensitive, walk_all_files},
+};
+
+pub fn resolve_files_for_install(
+    root_config: &RootConfig,
+    instance: &ModdedInstance,
+    mod_to_install: &ModConfig,
+) -> anyhow::Result<Vec<ModFile>> {
+    let mod_location = root_config.mod_location().join(mod_to_install.path());
+
+    let files = match determain_mod_kind(mod_to_install, &mod_location)? {
+        ModKind::Fomod(xml_path) => install_fomod(instance, xml_path, &mod_location)?,
+        ModKind::EmbeddedData(_data_path) => install_from_dir(mod_to_install, mod_location)?,
+        ModKind::Root => install_root(mod_to_install, mod_location)?,
+        ModKind::Unkown => install_from_dir_to_data(mod_to_install, mod_location)?,
+    };
+
+    Ok(files)
+}
+
+fn determain_mod_kind(
+    mod_config: &ModConfig,
+    mod_location: impl AsRef<Path>,
+) -> Result<ModKind, io::Error> {
+    if mod_config.is_root_mod() {
+        return Ok(ModKind::Root);
+    }
+
+    // Check for moduleconfig.xml
+    let module_config_path = resolve_case_insensitive(&mod_location, "fomod/ModuleConfig.xml")?;
+
+    if let Some(path) = module_config_path {
+        return Ok(ModKind::Fomod(path));
+    };
+
+    match resolve_case_insensitive(&mod_location, "data")? {
+        Some(data_path) => Ok(ModKind::EmbeddedData(data_path)),
+        None => Ok(ModKind::Unkown),
+    }
+}
+
+fn install_fomod(
+    instance: &ModdedInstance,
+    module_config_path: impl AsRef<Path>,
+    mod_root: impl AsRef<Path>,
+) -> anyhow::Result<Vec<ModFile>> {
+    debug!("Running FOmod installer");
+    let module_config = fomod::Config::load_from_file(module_config_path)?;
+
+    let active_plugins: Vec<_> = instance
+        .active_plugins()
+        .map(|e| e.to_string_lossy())
+        .map(|e| e.to_string())
+        .collect();
+
+    trace!("Current loded plugins: {:?}", active_plugins);
+    let files = run_fomod_installer(module_config, &active_plugins, install_prompt::prompt)?;
+
+    let mod_files: Vec<_> = files
+        .iter()
+        .map(|f| ModFile::from_installer(f.clone(), &mod_root))
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .flatten()
+        .collect();
+    Ok(mod_files)
+}
+
+fn install_from_dir(
+    mod_config: &ModConfig,
+    mod_location: impl AsRef<Path>,
+) -> anyhow::Result<Vec<ModFile>> {
+    let glob_filter = create_glob_filter(mod_config.ignore())?;
+
+    let files: Vec<_> = walk_all_files(&mod_location)?
+        .map(|entry| entry.path().strip_prefix(&mod_location).unwrap().to_owned())
+        .filter(|rel_path| !glob_filter.is_match(rel_path))
+        .filter(|rel_path| should_be_included(rel_path))
+        .map(|rel_path| ModFile::new(&rel_path, &rel_path, 0))
+        .collect();
+
+    Ok(files)
+}
+
+fn install_root(
+    mod_config: &ModConfig,
+    mod_location: impl AsRef<Path>,
+) -> anyhow::Result<Vec<ModFile>> {
+    let glob_filter = create_glob_filter(mod_config.ignore())?;
+
+    let files: Vec<_> = walk_all_files(&mod_location)?
+        .map(|entry| entry.path().strip_prefix(&mod_location).unwrap().to_owned())
+        .filter(|rel_path| !glob_filter.is_match(rel_path))
+        .map(|rel_path| ModFile::new(&rel_path, &rel_path, 0))
+        .collect();
+
+    Ok(files)
+}
+
+fn install_from_dir_to_data(
+    mod_config: &ModConfig,
+    path: impl AsRef<Path>,
+) -> anyhow::Result<Vec<ModFile>> {
+    let glob_filter = create_glob_filter(mod_config.ignore())?;
+    let data = PathBuf::from("Data");
+    let files: Vec<ModFile> = walk_all_files(&path)?
+        .map(|entry| entry.path().strip_prefix(&path).unwrap().to_owned())
+        .filter(|rel_path| !glob_filter.is_match(rel_path))
+        .filter(|rel_path| should_be_included(rel_path))
+        .map(|rel_path| ModFile::new(&rel_path, data.join(&rel_path), 0))
+        .collect();
+
+    Ok(files)
+}
+
+fn create_glob_filter(rules: &[String]) -> anyhow::Result<GlobSet> {
+    let mut builder = GlobSetBuilder::new();
+
+    for p in rules {
+        builder.add(Glob::new(p)?);
+    }
+
+    let set = builder.build()?;
+    Ok(set)
+}
+
+enum ModKind {
+    Fomod(PathBuf),
+    EmbeddedData(PathBuf),
+    Root,
+    Unkown,
+}
+
+fn should_be_included(path: impl AsRef<Path>) -> bool {
+    matches!(
+        path.as_ref().extension().and_then(|e| e.to_str()),
+        Some(
+            "esp"
+                | "esm"
+                | "esl"
+                | "bsa"
+                | "ba2"
+                | "bsl"
+                | "ini"
+                | "pex"
+                | "psc"
+                | "strings"
+                | "ilstrings"
+                | "dlstrings"
+                | "dll"
+                | "swf"
+        )
+    )
+}

src/actions/load_order.rs

@@ -0,0 +1,95 @@
+use libloot::{
+    Game, GameType,
+    error::{GameHandleCreationError, LoadPluginsError, SortPluginsError},
+};
+use log::trace;
+use std::{
+    io,
+    path::{Path, PathBuf},
+};
+use thiserror::Error;
+use walkdir::WalkDir;
+
+use crate::{
+    types::{self, ModdedInstance, RootConfig},
+    utils::is_plugin_file,
+};
+
+pub fn create_loadorder(
+    root_config: &RootConfig,
+    game: &types::Game,
+    instance: &ModdedInstance,
+) -> Result<Vec<String>, LoadOrderError> {
+    let mut loot_game = Game::with_local_path(
+        GameType::SkyrimSE,
+        game.install_location(),
+        &game.install_location().join(PathBuf::from("appdata")),
+    )?;
+
+    // Add plugins files from the game install
+    let install_plugins: Vec<PathBuf> = WalkDir::new(game.install_location().join("Data"))
+        .into_iter()
+        .map(|entry| {
+            let entry = entry?;
+            let path = entry.path();
+
+            if is_plugin_file(path) {
+                Ok(Some(path.to_path_buf()))
+            } else {
+                Ok(None)
+            }
+        })
+        .filter_map(|r| r.transpose())
+        .collect::<Result<_, io::Error>>()?;
+
+    // The loaded_plugins function requires &[&Path]
+    let refs: Vec<&Path> = install_plugins.iter().map(|e| e.as_path()).collect();
+
+    trace!("Loading {} plugins to game", refs.len());
+    loot_game.load_plugins(&refs)?;
+
+    // Add plugins from the instance
+    let instance_plugins: Vec<_> = instance
+        .mods()
+        .iter()
+        .flat_map(|installed_mod| {
+            let mod_config = root_config.mod_by_id(installed_mod.mod_id()).unwrap();
+            let mod_source_root = root_config.mod_location().join(mod_config.path());
+
+            installed_mod
+                .files()
+                .iter()
+                .filter(|f| is_plugin_file(f.dst()))
+                .map(move |link| mod_source_root.join(link.src()))
+        })
+        .collect();
+
+    let refs: Vec<_> = instance_plugins.iter().map(|e| e.as_path()).collect();
+
+    trace!("Loading {} plugins to game", refs.len());
+
+    loot_game.load_plugins(&refs)?;
+
+    // Genrate load order
+    let all_plugins = loot_game.loaded_plugins();
+    let plugins_names: Vec<&str> = all_plugins.iter().map(|e| e.name()).collect();
+
+    let sorted = loot_game.sort_plugins(&plugins_names)?;
+
+    Ok(sorted)
+}
+
+#[derive(Error, Debug)]
+pub enum LoadOrderError {
+    #[error("Failed to read game directory")]
+    Io(#[from] io::Error),
+
+    #[error("Failed to create libloot game")]
+    Creating(#[from] GameHandleCreationError),
+
+    #[error("Failed to add plugins to libloot")]
+    Loading(#[from] LoadPluginsError),
+
+    #[error("libloot failed to sort plugins")]
+    Sorting(#[from] SortPluginsError),
+}

src/cli.rs

@@ -0,0 +1,22 @@
+use std::path::PathBuf;
+
+use clap::{Parser, Subcommand};
+
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct Args {
+    #[arg(short, long, value_name = "FILE")]
+    pub config: PathBuf,
+
+    #[command(subcommand)]
+    pub command: Commands,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum Commands {
+    Activate { instance: String, target: PathBuf },
+    Include { instance: String, mod_id: String },
+    LoadOrder { instance: String },
+    ApiCheck,
+    Download { url: String },
+}

src/file_conflict_solver.rs

@@ -0,0 +1,219 @@
+use std::{collections::HashMap, path::PathBuf};
+
+use log::debug;
+
+use crate::types::{InstalledMod, ModFile};
+
+#[derive(Debug)]
+pub struct Conflict<'a> {
+    pub rhs_mod: &'a InstalledMod,
+    pub lhs_mod: &'a InstalledMod,
+    pub rhs_file: &'a ModFile,
+    pub lhs_file: &'a ModFile,
+}
+
+pub struct ConflictSolver<'a> {
+    files: HashMap<PathBuf, (&'a ModFile, &'a InstalledMod)>,
+}
+
+impl<'a> ConflictSolver<'a> {
+    pub fn new() -> Self {
+        Self {
+            files: HashMap::new(),
+        }
+    }
+
+    pub fn add_file(
+        &mut self,
+        file: &'a ModFile,
+        from_mod: &'a InstalledMod,
+    ) -> Option<Conflict<'a>> {
+        let path = &file.dst().to_owned();
+        match self.files.get(path) {
+            Some((current_file, current_file_mod)) => {
+                debug!(
+                    "Trying to resolve file conflict between at {}",
+                    path.to_string_lossy()
+                );
+
+                if from_mod == *current_file_mod {
+                    // File from the same mod
+                    // Check internal priority
+                    if file.internal_priority() > current_file.internal_priority() {
+                        self.files.insert(path.to_owned(), (file, from_mod));
+                        debug!("Conflict resolved. Internal priority");
+                        return None;
+                    }
+
+                    if file.internal_priority() == current_file.internal_priority() {
+                        // Same prio. We got a conflict.
+
+                        return Some(Conflict {
+                            rhs_mod: from_mod,
+                            lhs_mod: current_file_mod,
+                            rhs_file: file,
+                            lhs_file: current_file,
+                        });
+                    }
+                }
+
+                if from_mod.priority() > current_file_mod.priority() {
+                    self.files.insert(path.to_owned(), (file, from_mod));
+                    debug!("Conflict resolved. Mod priority");
+                    return None;
+                }
+
+                if from_mod.priority() == current_file_mod.priority() {
+                    // Different mod but priority the same. We got a conflict.
+                    return Some(Conflict {
+                        rhs_mod: from_mod,
+                        lhs_mod: current_file_mod,
+                        rhs_file: file,
+                        lhs_file: current_file,
+                    });
+                }
+            }
+            None => {
+                self.files.insert(path.to_owned(), (file, from_mod));
+            }
+        }
+
+        None
+    }
+
+    pub fn export_files(&self) -> Vec<(&'a ModFile, &'a InstalledMod)> {
+        self.files.iter().map(|e| e.1.to_owned()).collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn no_conflict() {
+        let mut solver = ConflictSolver::new();
+
+        let mod1 = InstalledMod::new("mod1", 0);
+        let m1f1 = ModFile::new("Data/Plugin1.esp", "Data/Plugin1.esp", 0);
+
+        let mod2 = InstalledMod::new("mod2", 0);
+        let m2f1 = ModFile::new("Data/Plugin2.esp", "Data/Plugin2.esp", 0);
+
+        assert!(solver.add_file(&m1f1, &mod1).is_none());
+        assert!(solver.add_file(&m2f1, &mod2).is_none());
+
+        let export = solver.export_files();
+        assert_eq!(export.len(), 2);
+        assert!(
+            export
+                .iter()
+                .find(|e| e.1 == &mod1 && e.0 == &m1f1)
+                .is_some(),
+            "Missing mod1 file1"
+        );
+        assert!(
+            export
+                .iter()
+                .find(|e| e.1 == &mod2 && e.0 == &m2f1)
+                .is_some(),
+            "Missing mod2 file1"
+        );
+    }
+
+    #[test]
+    fn conflict_same_mod_solved() {
+        let mut solver = ConflictSolver::new();
+
+        let mod1 = InstalledMod::new("mod1", 0);
+        let m1f1 = ModFile::new("Data/Plugin1.esp", "Data/Plugin.esp", 0);
+        let m1f2 = ModFile::new("Data/Plugin_alt.esp", "Data/Plugin.esp", 1);
+
+        assert!(solver.add_file(&m1f1, &mod1).is_none());
+        assert!(solver.add_file(&m1f2, &mod1).is_none());
+
+        let export = solver.export_files();
+        assert_eq!(export.len(), 1);
+        assert!(
+            export
+                .iter()
+                .find(|e| e.1 == &mod1 && e.0 == &m1f2)
+                .is_some(),
+            "Missing mod1 file2"
+        );
+    }
+
+    #[test]
+    fn conflict_diff_mod_solved() {
+        let mut solver = ConflictSolver::new();
+
+        let mod1 = InstalledMod::new("mod1", 0);
+        let m1f1 = ModFile::new("Data/Plugin1.esp", "Data/Plugin.esp", 0);
+
+        let mod2 = InstalledMod::new("mod2", 1);
+        let m2f1 = ModFile::new("Data/Plugin.esp", "Data/Plugin.esp", 0);
+
+        assert!(solver.add_file(&m1f1, &mod1).is_none());
+        assert!(solver.add_file(&m2f1, &mod2).is_none());
+
+        let export = solver.export_files();
+        assert_eq!(export.len(), 1);
+        assert!(
+            export
+                .iter()
+                .find(|e| e.1 == &mod2 && e.0 == &m2f1)
+                .is_some(),
+            "Missing mod2 file1"
+        );
+    }
+
+    #[test]
+    fn conflict_same_mod() {
+        let mut solver = ConflictSolver::new();
+
+        let mod1 = InstalledMod::new("mod1", 0);
+        let m1f1 = ModFile::new("Data/Plugin1.esp", "Data/Plugin.esp", 0);
+        let m1f2 = ModFile::new("Data/Plugin_alt.esp", "Data/Plugin.esp", 0);
+
+        assert!(solver.add_file(&m1f1, &mod1).is_none());
+        let conflict = solver.add_file(&m1f2, &mod1);
+
+        assert!(conflict.is_some());
+        let unwraped = conflict.expect("Aserted before");
+
+        assert!(
+            unwraped.rhs_mod == unwraped.lhs_mod,
+            "Not same mod in conflict"
+        );
+        assert!(unwraped.rhs_file != unwraped.lhs_file, "Files are the same");
+        assert!(
+            unwraped.rhs_file == &m1f1 || unwraped.rhs_file == &m1f2,
+            "One file not found in conflict "
+        );
+    }
+
+    #[test]
+    fn conflict_diff_mod() {
+        let mut solver = ConflictSolver::new();
+
+        let mod1 = InstalledMod::new("mod1", 0);
+        let m1f1 = ModFile::new("Data/Plugin1.esp", "Data/Plugin.esp", 0);
+
+        let mod2 = InstalledMod::new("mod2", 0);
+        let m2f1 = ModFile::new("Data/Plugin.esp", "Data/Plugin.esp", 0);
+
+        assert!(solver.add_file(&m1f1, &mod1).is_none());
+        let conflict = solver.add_file(&m2f1, &mod2);
+
+        assert!(conflict.is_some());
+        let unwraped = conflict.expect("Aserted before");
+
+        assert!(unwraped.rhs_mod != unwraped.lhs_mod, "Same mod in conflict");
+        assert!(unwraped.rhs_file != unwraped.lhs_file, "Files are the same");
+        assert!(
+            unwraped.rhs_file == &m1f1 || unwraped.lhs_file == &m1f1,
+            "One file not found in conflict "
+        );
+        assert_eq!(unwraped.rhs_file.dst(), "Data/Plugin.esp");
+    }
+}

src/fomod.rs

@@ -2,7 +2,11 @@
 // https://github.com/luctius/fomod/
 // Original license: MIT / Apache-2.0
 
+use std::{fs, io, path::Path};
+
+use log::debug;
 use serde::{Deserialize, Serialize};
+use thiserror::Error;
 
 #[derive(Debug, Deserialize, PartialEq)]
 pub struct Info {
@@ -20,6 +24,15 @@ pub struct Info {
     pub category_id: Option<usize>,
 }
 
+impl Info {
+    pub fn load_from_file(path: impl AsRef<Path>) -> Result<Self, FOModError> {
+        let data = fs::read_to_string(path)?;
+        let config = quick_xml::de::from_str(&data)?;
+
+        Ok(config)
+    }
+}
+
 #[derive(Debug, Deserialize, PartialEq)]
 pub struct Config {
     #[serde(rename = "moduleName")]
@@ -41,6 +54,29 @@ pub struct Config {
     pub conditional_file_installs: Option<ConditionalFileInstallList>,
 }
 
+impl Config {
+    pub fn load_from_file(path: impl AsRef<Path>) -> Result<Self, FOModError> {
+        debug!(
+            "Loading FOmod config from {}",
+            path.as_ref().to_string_lossy()
+        );
+
+        let data = fs::read_to_string(path)?;
+        let config = quick_xml::de::from_str(&data)?;
+
+        Ok(config)
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum FOModError {
+    #[error("Failed to read file")]
+    Io(#[from] io::Error),
+
+    #[error("Failed to parse config")]
+    Parse(#[from] quick_xml::de::DeError),
+}
+
 #[derive(
     Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash, Default,
 )]
@@ -82,6 +118,7 @@ pub enum PluginTypeDescriptorEnum {
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DependencyPluginType {
+    #[serde(rename = "defaultType")]
     pub default_type: PluginType,
     pub patterns: DependencyPatternList,
 }
@@ -93,7 +130,7 @@ pub struct DependencyPatternList {
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DependencyPattern {
-    pub dependencies: CompositeDependency,
+    pub dependencies: Vec<CompositeDependency>,
     #[serde(rename = "type")]
     pub typ: PluginType,
 }
@@ -112,7 +149,7 @@ pub struct InstallStep {
     #[serde(rename = "@name")]
     pub name: String,
 
-    pub visible: Option<CompositeDependency>,
+    pub visible: Option<ModuleDependency>,
 
     #[serde(rename = "optionalFileGroups")]
     pub optional_file_groups: GroupList,
@@ -121,6 +158,7 @@ pub struct InstallStep {
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ModuleDependency {
     #[serde(rename = "@operator")]
+    #[serde(default)]
     pub operator: DependencyOperator,
     #[serde(rename = "$value")]
     pub list: Vec<CompositeDependency>,
@@ -177,8 +215,11 @@ pub enum DependencyState {
     Missing,
 }
 
-#[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(
+    Copy, Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash,
+)]
 pub enum DependencyOperator {
+    #[default]
     And,
     Or,
 }
@@ -307,7 +348,7 @@ pub struct ConditionalInstallPatternList {
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ConditionalInstallPattern {
-    pub dependencies: CompositeDependency,
+    pub dependencies: ModuleDependency, 
     pub files: FileList,
 }
 

src/lib.rs

@@ -0,0 +1,10 @@
+pub mod cli;
+pub mod file_conflict_solver;
+pub mod fomod;
+pub mod install_prompt;
+pub mod mod_config_installer;
+pub mod nexus;
+pub mod types;
+pub mod unpacker;
+pub mod utils;
+pub mod actions;

src/linker.rs

@@ -1,146 +0,0 @@
-use std::{
-    fs, io,
-    os::unix,
-    path::{Path, PathBuf},
-};
-
-use crate::fomod::FileTypeEnum;
-
-pub struct Linker {
-    target: PathBuf,
-}
-
-impl Linker {
-    pub fn new(target_path: &Path) -> Self {
-        Self {
-            target: target_path.to_owned(),
-        }
-    }
-
-    #[inline]
-    fn install_path(&self) -> &Path {
-        &self.target
-    }
-
-    fn link_file(&self, from: &Path, to: &Path) -> Result<(), LinkerError> {
-        let target = self.install_path().join(path_to_lowercase(to));
-
-        if let Some(parent) = target.parent() {
-            fs::create_dir_all(parent)?;
-        }
-
-        unix::fs::symlink(from, target)?;
-        Ok(())
-    }
-
-    fn remove_link(&self, to: &Path) -> Result<(), LinkerError> {
-        let file = self.install_path().join(path_to_lowercase(to));
-        let metadata = fs::symlink_metadata(&file)?;
-
-        if !metadata.file_type().is_symlink() {
-            return Err(LinkerError::NotASymlink(file));
-        }
-
-        fs::remove_file(&file)?;
-        Ok(())
-    }
-
-    fn link_recursive(&self, from: &Path, to: &Path) -> Result<(), LinkerError> {
-        for entry in fs::read_dir(from)? {
-            let entry = entry?;
-            let entry_path = entry.path();
-            let relative = entry_path
-                .strip_prefix(from)
-                .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
-            let target_path = to.join(relative);
-
-            if entry_path.is_dir() {
-                self.link_recursive(&entry_path, &target_path)?;
-            } else {
-                self.link_file(&entry_path, &target_path)?;
-            }
-        }
-
-        Ok(())
-    }
-
-    fn unlink_recursive(&self, from: &Path, to: &Path) -> Result<(), LinkerError> {
-        for entry in fs::read_dir(from)? {
-            let entry = entry?;
-            let entry_path = entry.path();
-            let relative = entry_path
-                .strip_prefix(from)
-                .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
-            let target_path = to.join(relative);
-
-            if entry_path.is_dir() {
-                self.unlink_recursive(&entry_path, &target_path)?;
-
-                let install_target = self.install_path().join(&target_path);
-                if install_target.exists() && fs::read_dir(&install_target)?.next().is_none() {
-                    fs::remove_dir(&install_target)?;
-                }
-            } else {
-                self.remove_link(&target_path)?;
-            }
-        }
-
-        Ok(())
-    }
-
-    pub fn link_plugin_files(
-        &self,
-        entries: &[FileTypeEnum],
-        mod_dir: &Path,
-    ) -> Result<(), LinkerError> {
-        let mut sorted_entries = entries.to_owned();
-        sorted_entries.sort_by_cached_key(|e| match e {
-            FileTypeEnum::File(file_type) => file_type.priority.unwrap_or(0),
-            FileTypeEnum::Folder(file_type) => file_type.priority.unwrap_or(0),
-        });
-
-        for entry in sorted_entries {
-            match entry {
-                FileTypeEnum::File(file) => {
-                    let from = mod_dir.join(file.source);
-                    let to = Path::new("Data").join(file.destination.unwrap_or("".to_owned()));
-                    self.link_file(&from, &to)?;
-                }
-                FileTypeEnum::Folder(folder) => {
-                    let from = mod_dir.join(folder.source);
-                    let to = Path::new("Data").join(folder.destination.unwrap_or("".to_owned()));
-                    self.link_recursive(&from, &to)?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub enum LinkerError {
-    Io(io::Error),
-    NotASymlink(PathBuf),
-}
-
-impl std::fmt::Display for LinkerError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Io(e) => write!(f, "IO error: {}", e),
-            Self::NotASymlink(path) => write!(f, "Tried to remove a non symlink: {:?}", path),
-        }
-    }
-}
-
-impl std::error::Error for LinkerError {}
-
-impl From<io::Error> for LinkerError {
-    fn from(e: io::Error) -> Self {
-        Self::Io(e)
-    }
-}
-
-fn path_to_lowercase(path: &Path) -> PathBuf {
-    PathBuf::from(path.to_string_lossy().to_lowercase())
-}

src/main.rs

@@ -1,22 +1,108 @@
-use std::{error::Error, fs};
+use anyhow::anyhow;
+use clap::Parser;
+use log::{debug, error, info};
+use std::{error::Error, path::Path};
 
-use crate::mod_config_installer::FomodInstaller;
+use fomod_manager::{
+    actions::{
+        activate_instance, create_loadorder, handle_nxm, insert_mod_to_instance,
+        resolve_files_for_install,
+    },
+    cli::{self, Args},
+    nexus::NexusAPI,
+    types::RootConfig,
+};
 
-mod install_prompt;
+fn command_activate(
-mod mod_config_installer;
+    root_config: &RootConfig,
-mod linker;
+    instance_id: &str,
-mod fomod;
+    target: impl AsRef<Path>,
+) -> anyhow::Result<()> {
+    let instance = root_config.load_instance_by_id(instance_id)?;
+    activate_instance(root_config, &instance, target)?;
+    Ok(())
+}
 
-fn main() -> Result<(), Box<dyn Error>> {
+fn command_add(root_config: &RootConfig, instance_id: &str, mod_id: &str) -> anyhow::Result<()> {
-    const XML_PATH: &str = "./data/xml/ineed.xml";
+    let mut instance = root_config.load_instance_by_id(instance_id)?;
+    let mod_to_install = root_config
+        .mod_by_id(mod_id)
+        .ok_or(anyhow!("Can't find mod in config"))?;
 
-    let xml = fs::read_to_string(XML_PATH)?;
+    let files = resolve_files_for_install(root_config, &instance, &mod_to_install)?;
 
-    let config: fomod::Config = quick_xml::de::from_str(&xml)?;
+    match insert_mod_to_instance(&mut instance, &mod_to_install, &files, 0) {
+        None => {
+            instance.save_to_file()?;
+            Ok(())
+        }
+        Some(conflict) => {
+            error!(
+                "File conflict between {} and {} at {}",
+                conflict.lhs_mod_id,
+                conflict.rhs_mod_id,
+                conflict.path.to_string_lossy()
+            );
+            info!("To resolve file conflicts give one mod a higher priority in the config");
 
-    let installer = FomodInstaller::new(config, vec![], install_prompt::prompt);
+            Err(anyhow!("File conflict"))
+        }
+    }
+}
 
-    dbg!(installer.run());
+fn command_order(root_config: &RootConfig, instance_id: &str) -> anyhow::Result<()> {
+    let mut instance = root_config.load_instance_by_id(instance_id)?;
+    let game = root_config.game_by_id(instance.game_id()).unwrap();
+
+    let new_load_order = create_loadorder(root_config, &game, &instance)?;
+    instance.set_load_order(new_load_order);
+    instance.save_to_file()?;
+
+    Ok(())
+}
+
+fn command_download(root_config: &mut RootConfig, raw_url: &str) -> anyhow::Result<()> {
+    handle_nxm(root_config, raw_url)?;
+
+    root_config.save_to_file()?;
+
+    Ok(())
+}
+
+fn setup_logger() {
+    env_logger::builder()
+        .filter_level(log::LevelFilter::max())
+        .format_timestamp(None)
+        .filter_module("ureq_proto::util", log::LevelFilter::Debug)
+        .filter_module("rustls::client::hs", log::LevelFilter::Debug)
+        .init();
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    setup_logger();
+    let args = Args::parse();
+
+    debug!("Loading config from {:?}", args.config);
+    let mut root_config = RootConfig::load_from_file(args.config)?;
+
+    match args.command {
+        cli::Commands::Activate { instance, target } => {
+            command_activate(&root_config, &instance, &target)?;
+        }
+        cli::Commands::Include { instance, mod_id } => {
+            command_add(&root_config, &instance, &mod_id)?;
+        }
+        cli::Commands::LoadOrder { instance } => {
+            command_order(&root_config, &instance)?;
+        }
+        cli::Commands::ApiCheck => {
+            let api = NexusAPI::new(root_config.nexus_api_key().unwrap());
+            api.validate_key()?;
+        }
+        cli::Commands::Download { url } => {
+            command_download(&mut root_config, &url)?;
+        }
+    }
 
     Ok(())
 }

src/mod_config_installer.rs

@@ -1,17 +1,15 @@
 use std::{collections::HashMap, fmt::Display};
 
+use log::{debug, warn};
+
 use crate::fomod::{
     CompositeDependency, Config, DependencyOperator, DependencyState, FileList, FileTypeEnum,
-    Group, GroupType, Plugin, PluginTypeDescriptorEnum, PluginTypeEnum,
+    Group, GroupType, ModuleDependency, Plugin, PluginTypeDescriptorEnum, PluginTypeEnum,
 };
 
 #[derive(Debug)]
-pub struct InstallerState {
+struct InstallerState {
-    /// Flags set by plugin selections throughout the install
     flags: HashMap<String, String>,
-
-    /// Files to install, keyed by destination path.
-    /// Higher priority value wins when destinations conflict.
     selected_files: Vec<FileTypeEnum>,
 }
 
@@ -24,6 +22,7 @@ impl InstallerState {
     }
 
     fn set_flag(&mut self, name: &str, value: &str) {
+        debug!("Setting flag: {} to {}", name, value);
         self.flags.insert(name.to_string(), value.to_string());
     }
 
@@ -33,13 +32,14 @@ impl InstallerState {
 
     fn add_files(&mut self, files: &FileList) {
         let Some(list) = &files.list else {
+            debug!("Adding empty file list to installer state");
             return;
         };
 
         self.selected_files.extend_from_slice(list);
     }
 
-    pub fn into_file_list(self) -> Vec<FileTypeEnum> {
+    fn into_file_list(self) -> Vec<FileTypeEnum> {
         self.selected_files
     }
 }
@@ -70,12 +70,20 @@ fn evaluate_dependency(
         CompositeDependency::Game(version) => {
             // TODO: Check the game version
             let _ = version;
+            warn!(
+                "Trying to eveluate game version dependency: {} - Not implemented yet.",
+                version.version
+            );
             true
         }
 
         CompositeDependency::Fomm(version) => {
             // TODO: Check the fomm version
             let _ = version;
+            warn!(
+                "Trying to eveluate FOMM dependency: {} - Not implemented yet.",
+                version.version
+            );
             true
         }
 
@@ -93,30 +101,30 @@ fn evaluate_dependency(
     }
 }
 
+fn evaluate_module_depbendecy(
+    dep: &ModuleDependency,
+    state: &InstallerState,
+    installed_plugins: &[String],
+) -> bool {
+    let mut evaluated = dep
+        .list
+        .iter()
+        .map(|e| evaluate_dependency(e, state, installed_plugins));
+
+    match dep.operator {
+        DependencyOperator::And => evaluated.all(|r| r),
+        DependencyOperator::Or => evaluated.any(|r| r),
+    }
+}
+
 pub struct GroupPrompt {
     pub name: String,
     pub select_type: GroupType,
     pub options: Vec<InstallOption>,
 }
 
-pub struct InstallOption {
+impl GroupPrompt {
-    pub name: String,
+    fn new(group: &Group, state: &InstallerState, installed_plugins: &[String]) -> Self {
-    pub option_type: PluginTypeEnum,
-    pub idx: usize,
-    pub description: String,
-}
-
-impl Display for InstallOption {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{} ({:?})", self.name, self.option_type)
-    }
-}
-
-fn create_group_prompt(
-    group: &Group,
-    state: &InstallerState,
-    installed_plugins: &[String],
-) -> GroupPrompt {
         let options = group
             .plugins
             .plugin
@@ -130,12 +138,26 @@ fn create_group_prompt(
             })
             .collect();
 
-    GroupPrompt {
+        Self {
             name: group.name.clone(),
             select_type: group.typ,
             options,
         }
     }
+}
+
+pub struct InstallOption {
+    pub name: String,
+    pub option_type: PluginTypeEnum,
+    pub idx: usize,
+    pub description: String,
+}
+
+impl Display for InstallOption {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} ({:?})", self.name, self.option_type)
+    }
+}
 
 /// Each plugin in the install steps have a type. e.g.: Optional, Required, Recommended
 /// But the type depends on dependencies
@@ -154,7 +176,11 @@ fn resolve_plugin_type(
         PluginTypeDescriptorEnum::PluginType(plugin_type) => plugin_type.name,
         PluginTypeDescriptorEnum::DependencyType(dependency_plugin_type) => {
             for dep in &dependency_plugin_type.patterns.pattern {
-                if evaluate_dependency(&dep.dependencies, state, installed_plugins) {
+                if dep
+                    .dependencies
+                    .iter()
+                    .all(|e| evaluate_dependency(e, state, installed_plugins))
+                {
                     return dep.typ.name;
                 }
             }
@@ -165,51 +191,38 @@ fn resolve_plugin_type(
     }
 }
 
-pub struct FomodInstaller {
+pub fn run_fomod_installer(
-    config: Config,
+    fomod_config: Config,
-    installed_plugins: Vec<String>,
+    installed_plugins: &[String],
     group_prompt: fn(GroupPrompt) -> Vec<usize>,
-}
+) -> anyhow::Result<Vec<FileTypeEnum>> {
-
-impl FomodInstaller {
-    pub fn new(
-        config: Config,
-        installed_plugins: Vec<String>,
-        group_promt: fn(GroupPrompt) -> Vec<usize>,
-    ) -> Self {
-        Self {
-            config,
-            installed_plugins,
-            group_prompt: group_promt,
-        }
-    }
-
-    pub fn run(self) -> Vec<FileTypeEnum> {
     let mut state = InstallerState::new();
 
     // Always-installed files first
-        if let Some(required) = &self.config.required_install_files {
+    if let Some(required) = &fomod_config.required_install_files {
         state.add_files(required);
     }
 
-        if let Some(install_steps) = &self.config.install_steps {
+    if let Some(install_steps) = fomod_config.install_steps {
         let steps = &install_steps.install_step;
 
-            for (step_index, step) in steps.iter().enumerate() {
+        for step in steps {
             // Check if the step should be visible
-                if let Some(visible) = &step.visible {
+            if step
-                    if !evaluate_dependency(visible, &state, &self.installed_plugins) {
+                .visible
+                .as_ref()
+                .is_some_and(|v| !evaluate_module_depbendecy(v, &state, installed_plugins))
+            {
                 // Dependency to show the step not meet. Skipping.
                 continue;
             }
-                }
 
             for group in &step.optional_file_groups.group {
                 // TODO: Skip groups where all plugins are NotUsable
 
-                    let prompt = create_group_prompt(group, &state, &self.installed_plugins);
+                let prompt = GroupPrompt::new(group, &state, installed_plugins);
 
-                    let selected_plugins = (self.group_prompt)(prompt);
+                let selected_plugins = (group_prompt)(prompt);
 
                 for i in selected_plugins {
                     let plugin = &group.plugins.plugin[i];
@@ -231,14 +244,13 @@ impl FomodInstaller {
     }
 
     // Evaluate conditional file installs based on final flag state
-        if let Some(conditional) = &self.config.conditional_file_installs {
+    if let Some(conditional) = &fomod_config.conditional_file_installs {
         for pattern in &conditional.patterns.pattern {
-                if evaluate_dependency(&pattern.dependencies, &state, &self.installed_plugins) {
+            if evaluate_module_depbendecy(&pattern.dependencies, &state, installed_plugins) {
                 state.add_files(&pattern.files);
             }
         }
     }
 
-        state.into_file_list()
+    Ok(state.into_file_list())
-    }
 }

src/nexus.rs

@@ -0,0 +1,7 @@
+mod api;
+mod downloader;
+mod url;
+
+pub use api::{ModInfo, NexusAPI};
+pub use downloader::download_nxm;
+pub use url::NXMUrl;

src/nexus/api.rs

@@ -0,0 +1,154 @@
+use serde::Deserialize;
+use url::Url;
+
+use crate::{nexus::NXMUrl, types::GameType};
+
+const NEXUS_ENDPOINT: &str = "https://api.nexusmods.com";
+
+pub struct NexusAPI {
+    api_key: String,
+}
+
+impl NexusAPI {
+    pub fn new(api_key: &str) -> Self {
+        Self {
+            api_key: api_key.to_owned(),
+        }
+    }
+
+    pub fn validate_key(&self) -> anyhow::Result<()> {
+        let _body = ureq::get(format!("{}/v1/users/validate.json", NEXUS_ENDPOINT))
+            .header("apikey", &self.api_key)
+            .header("accept", "application/json")
+            .call()?
+            .body_mut()
+            .read_to_string()?;
+
+        Ok(())
+    }
+
+    pub fn mod_info(&self, game_name: &str, mod_id: &str) -> anyhow::Result<ModInfo> {
+        let mod_info: ModInfo = ureq::get(format!(
+            "{}/v1/games/{}/mods/{}.json",
+            NEXUS_ENDPOINT, game_name, mod_id
+        ))
+        .header("apikey", &self.api_key)
+        .header("accept", "application/json")
+        .call()?
+        .body_mut()
+        .read_json()?;
+
+        Ok(mod_info)
+    }
+
+    pub fn generate_download_link_for_file(
+        &self,
+        url: &NXMUrl,
+    ) -> anyhow::Result<Vec<DownloadLocation>> {
+        let mut req_url = Url::parse(NEXUS_ENDPOINT)?;
+
+        let path = format!(
+            "/v1/games/{}/mods/{}/files/{}/download_link.json",
+            url.game, url.mod_id, url.file
+        );
+        req_url.set_path(&path);
+
+        req_url
+            .query_pairs_mut()
+            .append_pair("key", &url.key)
+            .append_pair("expires", &url.expires);
+
+        let body: Vec<DownloadLocation> = ureq::get(req_url.to_string())
+            .header("apikey", &self.api_key)
+            .header("accept", "application/json")
+            .call()?
+            .body_mut()
+            .read_json()?;
+
+        Ok(body)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct DownloadLocation {
+    pub name: String,
+    pub short_name: String,
+    #[serde(rename = "URI")]
+    pub uri: String,
+}
+
+impl DownloadLocation {
+    pub fn parse_url(&self) -> Result<Url, url::ParseError> {
+        Url::parse(&self.uri)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ModInfo {
+    pub name: String,
+    // pub summary: String,
+    // pub description: String,
+    // pub picture_url: String,
+    // pub mod_downloads: u64,
+    // pub mod_unique_downloads: u64,
+    // pub uid: u64,
+    pub mod_id: u64,
+    // pub game_id: u64,
+    // pub allow_rating: bool,
+    pub domain_name: String,
+    // pub category_id: u64,
+    pub version: String,
+    // pub endorsement_count: u64,
+    // pub created_timestamp: u64,
+    // pub created_time: String,
+    // pub updated_timestamp: u64,
+    // pub updated_time: String,
+    // pub author: String,
+    // pub uploaded_by: String,
+    // pub uploaded_users_profile_url: String,
+    // pub contains_adult_content: bool,
+    // pub status: String,
+    // pub available: bool,
+    // pub user: String /* Complex struct */,
+    // pub endorsement: String /* Complex struct*/ ,
+}
+
+impl ModInfo {
+    /// Try to generate a id for a mod based on name, mod_id and version
+    pub fn generate_id(&self) -> String {
+        const MAX_CHARS: usize = 16;
+        const MIN_CHARS: usize = 8;
+
+        let mut short_name = String::new();
+
+        for word in self.name.split_whitespace() {
+            let cleaned: String = word.chars().filter(|c| !c.is_ascii_punctuation()).collect();
+
+            if cleaned.is_empty() {
+                continue;
+            }
+
+            if short_name.is_empty() {
+                short_name.push_str(&cleaned);
+            } else {
+                short_name.push('_');
+                short_name.push_str(&cleaned);
+            }
+
+            // Ensure at least two words, then stop when >= 8 chars
+            let words = short_name.matches('_').count() + 1;
+            if words >= 2 && short_name.len() >= MIN_CHARS {
+                break;
+            }
+        }
+
+        if short_name.len() > MAX_CHARS {
+            short_name.truncate(MAX_CHARS);
+        }
+        format!("{}-{}", short_name.to_lowercase(), self.mod_id)
+    }
+
+    pub fn get_game_type(&self) -> GameType {
+        GameType::from_nexus_domain(&self.domain_name).unwrap_or(GameType::Unknown)
+    }
+}

src/nexus/downloader.rs

@@ -0,0 +1,66 @@
+use std::{
+    fs::{File, create_dir_all},
+    io,
+    path::{Path, PathBuf},
+};
+
+use anyhow::anyhow;
+use log::info;
+
+use crate::nexus::{
+    NXMUrl, NexusAPI,
+    api::{DownloadLocation, ModInfo},
+};
+
+pub fn download_nxm(
+    api_key: &str,
+    nxm_url: &NXMUrl,
+    target_dir: impl AsRef<Path>,
+) -> anyhow::Result<(PathBuf, ModInfo)> {
+    let api = NexusAPI::new(api_key);
+
+    let mod_info = api.mod_info(&nxm_url.game, &nxm_url.mod_id)?;
+    let links = api.generate_download_link_for_file(nxm_url)?;
+    let selected_mirror = links.first().unwrap();
+    let url = selected_mirror.parse_url()?;
+    let original_filename = url.path_segments().and_then(|mut e| e.next_back()).unwrap();
+    let filename = gen_filename_for_mod(&mod_info, &nxm_url.file, original_filename);
+    let download_path = target_dir.as_ref().join(&nxm_url.game).join(filename);
+
+    if let Some(parent) = download_path.parent() {
+        create_dir_all(parent)?;
+    }
+
+    download_mod(selected_mirror, &download_path)?;
+
+    Ok((download_path, mod_info))
+}
+
+fn download_mod(mod_dl_link: &DownloadLocation, target: impl AsRef<Path>) -> anyhow::Result<()> {
+    info!("Downloading file from {}", mod_dl_link.name);
+
+    let (response, body) = ureq::get(mod_dl_link.parse_url()?.as_str())
+        .call()?
+        .into_parts();
+
+    if !response.status.is_success() {
+        return Err(anyhow!("Got status {}", response.status));
+    }
+
+    let mut file = File::create(target)?;
+    let mut reader = body.into_reader();
+
+    io::copy(&mut reader, &mut file)?;
+
+    Ok(())
+}
+
+fn gen_filename_for_mod(mod_info: &ModInfo, file_id: &str, dl_filename: &str) -> String {
+    let filename_from_url = PathBuf::from(dl_filename);
+    let ext = filename_from_url
+        .extension()
+        .unwrap_or_default()
+        .to_string_lossy();
+
+    format!("{}-{}.{}", mod_info.mod_id, file_id, ext)
+}

src/nexus/url.rs

@@ -0,0 +1,44 @@
+use url::Url;
+
+#[derive(Debug)]
+pub struct NXMUrl {
+    pub game: String,
+    pub mod_id: String,
+    pub file: String,
+    pub key: String,
+    pub user_id: String,
+    pub expires: String,
+}
+
+impl NXMUrl {
+    pub fn parse_url(raw: &str) -> Option<Self> {
+        // Example url
+        //nxm://skyrimspecialedition/mods/266/files/725705?key=xHxcFyx2_i5rhY1YdsSbyA&expires=1773086056&user_id=123456
+
+        let url = Url::parse(raw).ok()?;
+
+        let segs: Vec<&str> = url.path_segments()?.collect();
+
+        let game = url.host_str()?;
+        let mod_id = segs.get(1)?.parse().ok()?;
+        let file_id = segs.get(3)?.parse().ok()?;
+
+        let key = url.query_pairs().find(|(k, _)| k == "key")?.1;
+        let expires = url
+            .query_pairs()
+            .find(|(k, _)| k == "expires")?
+            .1
+            .parse()
+            .ok()?;
+        let user_id = url.query_pairs().find(|(k, _)| k == "user_id")?.1;
+
+        Some(Self {
+            game: game.to_owned(),
+            mod_id,
+            file: file_id,
+            key: key.to_string(),
+            user_id: user_id.parse().ok()?,
+            expires,
+        })
+    }
+}

src/types.rs

@@ -0,0 +1,39 @@
+use thiserror::Error;
+
+mod game;
+mod game_type;
+mod installed_mod;
+mod link;
+mod mod_config;
+mod mod_file;
+mod modded_instance;
+mod root_config;
+mod nexus_id;
+
+pub use game::*;
+pub use game_type::GameType;
+pub use installed_mod::*;
+pub use link::*;
+pub use mod_config::*;
+pub use mod_file::*;
+pub use modded_instance::*;
+pub use root_config::*;
+pub use nexus_id::*;
+
+#[derive(Error, Debug)]
+pub enum ConfigReadWriteError {
+    #[error("IO failure")]
+    Io(#[from] std::io::Error),
+
+    #[error("Failed to deserialize toml")]
+    Deserialize(#[from] toml::de::Error),
+
+    #[error("Failed to serialize to toml")]
+    Serialize(#[from] toml::ser::Error),
+
+    #[error("The provided ID could not be found")]
+    IDNotFound,
+
+    #[error("Could not determine the parent path of the file")]
+    NoParent, //fatty fatty no parents
+}

src/types/game.rs

@@ -0,0 +1,52 @@
+use std::{
+    collections::HashSet,
+    io,
+    path::{Path, PathBuf},
+};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    types::{GameType, link::Link},
+    utils::walk_all_files,
+};
+
+/// Available game
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Game {
+    path: PathBuf,
+    kind: GameType,
+}
+
+impl Game {
+    pub fn new(path: impl AsRef<Path>, game_type: GameType) -> Self {
+        Self {
+            path: path.as_ref().to_owned(),
+            kind: game_type,
+        }
+    }
+
+    pub fn export_links(&self) -> Result<HashSet<Link>, io::Error> {
+        let links: HashSet<Link> = walk_all_files(&self.path)?
+            .map(|entry| {
+                Link::new(
+                    entry.path(),
+                    entry
+                        .path()
+                        .strip_prefix(&self.path)
+                        .expect("Can't transform path back to relative. Should not happen."),
+                )
+            })
+            .collect();
+
+        Ok(links)
+    }
+
+    pub fn install_location(&self) -> &Path {
+        &self.path
+    }
+
+    pub fn game_type(&self) -> GameType {
+        self.kind.clone()
+    }
+}

src/types/game_type.rs

@@ -0,0 +1,186 @@
+use std::fmt::Display;
+
+use serde::{Deserialize, Deserializer, Serialize};
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub enum GameType {
+    Oblivion,
+    Skyrim,
+    Fallout3,
+    FalloutNV,
+    Fallout4,
+    SkyrimSE,
+    Fallout4VR,
+    SkyrimVR,
+    Morrowind,
+    Starfield,
+    OpenMW,
+    OblivionRemastered,
+    Custom(String),
+
+    #[default]
+    Unknown,
+}
+
+impl GameType {
+    pub fn to_libloot_type(self) -> Option<libloot::GameType> {
+        match self {
+            GameType::Oblivion => Some(libloot::GameType::Oblivion),
+            GameType::Skyrim => Some(libloot::GameType::Skyrim),
+            GameType::Fallout3 => Some(libloot::GameType::Fallout3),
+            GameType::FalloutNV => Some(libloot::GameType::FalloutNV),
+            GameType::Fallout4 => Some(libloot::GameType::Fallout4),
+            GameType::SkyrimSE => Some(libloot::GameType::SkyrimSE),
+            GameType::Fallout4VR => Some(libloot::GameType::Fallout4VR),
+            GameType::SkyrimVR => Some(libloot::GameType::SkyrimVR),
+            GameType::Morrowind => Some(libloot::GameType::Morrowind),
+            GameType::Starfield => Some(libloot::GameType::Starfield),
+            GameType::OpenMW => Some(libloot::GameType::OpenMW),
+            GameType::OblivionRemastered => Some(libloot::GameType::OblivionRemastered),
+            GameType::Custom(_) => None,
+            GameType::Unknown => None,
+        }
+    }
+
+    pub fn to_nexus_domain(self) -> Option<String> {
+        match self {
+            GameType::Oblivion => Some("oblivion".to_owned()),
+            GameType::Skyrim => Some("skyrim".to_owned()),
+            GameType::Fallout3 => Some("fallout3".to_owned()),
+            GameType::FalloutNV => Some("newvegas".to_owned()),
+            GameType::Fallout4 => Some("fallout4".to_owned()),
+            GameType::SkyrimSE => Some("skyrimspecialedition".to_owned()),
+            GameType::Fallout4VR => Some("fallout4".to_owned()),
+            GameType::SkyrimVR => Some("skyrimspecialedition".to_owned()),
+            GameType::Morrowind => Some("morrowind".to_owned()),
+            GameType::Starfield => Some("starfield".to_owned()),
+            GameType::OpenMW => Some("morrowind".to_owned()),
+            GameType::OblivionRemastered => Some("oblivionremastered".to_owned()),
+            GameType::Custom(_) => None,
+            GameType::Unknown => None,
+        }
+    }
+
+    pub fn from_nexus_domain(domain: &str) -> Option<Self> {
+        match domain {
+            "oblivion" => Some(GameType::Oblivion),
+            "skyrim" => Some(GameType::Skyrim),
+            "fallout3" => Some(GameType::Fallout3),
+            "newvegas" => Some(GameType::FalloutNV),
+            "fallout4" => Some(GameType::Fallout4),
+            "skyrimspecialedition" => Some(GameType::SkyrimSE),
+            "morrowind" => Some(GameType::Morrowind),
+            "starfield" => Some(GameType::Starfield),
+            "oblivionremastered" => Some(GameType::OblivionRemastered),
+            _ => None,
+        }
+    }
+}
+
+impl Display for GameType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            GameType::Oblivion => "Oblivion",
+            GameType::Skyrim => "Skyrim",
+            GameType::Fallout3 => "Fallout 3",
+            GameType::FalloutNV => "Fallout New Vegas",
+            GameType::Fallout4 => "Fallout 4",
+            GameType::SkyrimSE => "Skyrim Special Edition",
+            GameType::Fallout4VR => "Fallout 4 VR",
+            GameType::SkyrimVR => "Skyrim VR",
+            GameType::Morrowind => "Morrowind",
+            GameType::Starfield => "Starfield",
+            GameType::OpenMW => "OpenMW",
+            GameType::OblivionRemastered => "Oblivion Remastered",
+            GameType::Custom(name) => name,
+            GameType::Unknown => "Unknown",
+        };
+
+        write!(f, "{}", s)
+    }
+}
+
+impl<'de> Deserialize<'de> for GameType {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "oblivion" => Self::Oblivion,
+            "skyrim" => Self::Skyrim,
+            "fo3" => Self::Fallout3,
+            "fonv" => Self::FalloutNV,
+            "fo4" => Self::Fallout4,
+            "sse" => Self::SkyrimSE,
+            "fo4vr" => Self::Fallout4VR,
+            "skyrimvr" => Self::SkyrimVR,
+            "morrowind" => Self::Morrowind,
+            "starfield" => Self::Starfield,
+            "openmw" => Self::OpenMW,
+            "oblivionrm" => Self::OblivionRemastered,
+            "unknown" => Self::Unknown,
+            _ => Self::Custom(s),
+        })
+    }
+}
+
+impl Serialize for GameType {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let s = match self {
+            Self::Custom(s) => s,
+            Self::Oblivion => "oblivion",
+            Self::Skyrim => "skyrim",
+            Self::Fallout3 => "fo3",
+            Self::FalloutNV => "fonv",
+            Self::Fallout4 => "fo4",
+            Self::SkyrimSE => "sse",
+            Self::Fallout4VR => "fo4vr",
+            Self::SkyrimVR => "skyrimvr",
+            Self::Morrowind => "morrowind",
+            Self::Starfield => "starfield",
+            Self::OpenMW => "openmw",
+            Self::OblivionRemastered => "oblivionrm",
+            Self::Unknown => "unknown",
+        };
+
+        serializer.serialize_str(s)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Deserialize, Serialize, PartialEq, Debug)]
+    struct Wrapper {
+        value: GameType,
+    }
+
+    fn roundtrip(game_type: GameType) {
+        let val = Wrapper { value: game_type };
+        let serialized = toml::to_string(&val).unwrap();
+        let deserialized: Wrapper = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(val, deserialized);
+    }
+
+    #[test]
+    fn parse_back_and_forth_all() {
+        for e in [
+            GameType::Oblivion,
+            GameType::Skyrim,
+            GameType::Fallout3,
+            GameType::FalloutNV,
+            GameType::Fallout4,
+            GameType::SkyrimSE,
+            GameType::Fallout4VR,
+            GameType::SkyrimVR,
+            GameType::Morrowind,
+            GameType::Starfield,
+            GameType::OpenMW,
+            GameType::OblivionRemastered,
+            GameType::Custom("custom".to_owned()),
+            GameType::Unknown,
+        ] {
+            roundtrip(e);
+        }
+    }
+}

src/types/installed_mod.rs

@@ -0,0 +1,52 @@
+use std::{collections::HashSet, ffi::OsStr};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    types::{link::Link, mod_file::ModFile},
+    utils::is_plugin_file,
+};
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub struct InstalledMod {
+    id: String,
+    files: HashSet<Link>,
+    priority: isize,
+}
+
+impl InstalledMod {
+    pub fn new(root_mod_id: &str, priority: isize) -> Self {
+        Self {
+            id: root_mod_id.to_owned(),
+            files: HashSet::new(),
+            priority,
+        }
+    }
+
+    pub fn add_file(&mut self, file: &ModFile) {
+        self.files.insert(Link::from_mod_file(file));
+    }
+
+    /// Get the id of the mod
+    pub fn mod_id(&self) -> &str {
+        &self.id
+    }
+
+    /// The priority over other mods. Only used when 2 files conflict.
+    pub fn priority(&self) -> isize {
+        self.priority
+    }
+
+    /// The selected files
+    pub fn files(&self) -> &HashSet<Link> {
+        &self.files
+    }
+
+    pub fn active_plugins(&self) -> impl Iterator<Item = &OsStr> {
+        self.files
+            .iter()
+            .filter(|e| is_plugin_file(e.dst()))
+            .map(|e| e.dst())
+            .flat_map(|e| e.file_name())
+    }
+}

src/types/link.rs

@@ -0,0 +1,93 @@
+use serde::{
+    Deserialize, Deserializer, Serialize, Serializer,
+    de::{self, Visitor},
+};
+use std::{
+    fmt::{self, Debug},
+    path::{Path, PathBuf},
+};
+
+use crate::types::mod_file::ModFile;
+
+/// A link between a file from a mod and a destination in a ModdedInstance
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Link {
+    src: PathBuf,
+    dst: PathBuf,
+}
+
+impl Link {
+    pub fn new(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Self {
+        Self {
+            src: src.as_ref().to_owned(),
+            dst: dst.as_ref().to_owned(),
+        }
+    }
+
+    pub fn from_mod_file(file: &ModFile) -> Self {
+        Self::new(file.src(), file.dst())
+    }
+
+    pub fn src(&self) -> &Path {
+        &self.src
+    }
+
+    pub fn dst(&self) -> &Path {
+        &self.dst
+    }
+}
+
+impl Serialize for Link {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        if self.src == self.dst {
+            serializer.serialize_str(&self.src.to_string_lossy())
+        } else {
+            serializer.serialize_str(&format!(
+                "{} -> {}",
+                self.src.to_string_lossy(),
+                self.dst.to_string_lossy()
+            ))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Link {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct LinkVisitor;
+
+        impl<'de> Visitor<'de> for LinkVisitor {
+            type Value = Link;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str(r#"a string like "src -> dst" or "path" if they are the same"#)
+            }
+
+            fn visit_str<E: de::Error>(self, value: &str) -> Result<Link, E> {
+                match value.split_once(" -> ") {
+                    Some((src, dst)) => Ok(Link {
+                        src: PathBuf::from(src),
+                        dst: PathBuf::from(dst),
+                    }),
+                    None => Ok(Link {
+                        src: PathBuf::from(value),
+                        dst: PathBuf::from(value),
+                    }),
+                }
+            }
+        }
+
+        deserializer.deserialize_str(LinkVisitor)
+    }
+}
+
+impl From<ModFile> for Link {
+    fn from(value: ModFile) -> Self {
+        Self::new(value.src(), value.dst())
+    }
+}
+
+impl Debug for Link {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Link{{{:?} -> {:?}}}", self.src, self.dst,)
+    }
+}

src/types/mod_config.rs

@@ -0,0 +1,104 @@
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    nexus::ModInfo,
+    types::{GameType, NexusID},
+};
+
+/// Config for an available mod
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ModConfig {
+    /// ID of the mod
+    #[serde(skip)]
+    id: String,
+
+    /// Relative to the mod_location from root config
+    path: PathBuf,
+
+    /// If the files should be included on the root
+    #[serde(default)]
+    #[serde(skip_serializing_if = "is_false")]
+    root_mod: bool,
+
+    /// Globs of what files to ignore
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    ignore: Vec<String>,
+
+    name: Option<String>,
+
+    nexus_id: Option<NexusID>,
+
+    #[serde(default)]
+    #[serde(skip_serializing_if = "is_default")]
+    game: GameType,
+}
+
+impl ModConfig {
+    pub fn new(id: &str, source: impl AsRef<Path>) -> Self {
+        Self {
+            id: id.to_owned(),
+            path: source.as_ref().to_owned(),
+            root_mod: false,
+            ignore: Vec::new(),
+            name: None,
+            nexus_id: None,
+            game: GameType::Unknown,
+        }
+    }
+
+    pub fn from_mod_info(
+        id: &str,
+        source: impl AsRef<Path>,
+        mod_info: &ModInfo,
+        file_id: u64,
+    ) -> Self {
+        let mut normal = Self::new(id, source);
+        normal.name = Some(mod_info.name.clone());
+        normal.game = mod_info.get_game_type();
+        normal.nexus_id = Some(NexusID::new(mod_info.mod_id, file_id));
+
+        normal
+    }
+
+    pub fn add_id(mut self, id: &str) -> Self {
+        self.id = id.to_owned();
+        self
+    }
+
+    pub fn id(&self) -> &str {
+        &self.id
+    }
+
+    /// Get the relative path to the mod from the mod directory
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+
+    pub fn is_root_mod(&self) -> bool {
+        self.root_mod
+    }
+
+    pub fn ignore(&self) -> &[String] {
+        &self.ignore
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+
+    pub fn nexus_id(&self) -> Option<&NexusID> {
+        self.nexus_id.as_ref()
+    }
+}
+
+fn is_false(b: &bool) -> bool {
+    !b
+}
+
+fn is_default<T: Default + PartialEq>(t: &T) -> bool {
+    t == &T::default()
+}

src/types/mod_file.rs

@@ -0,0 +1,80 @@
+use std::path::{Path, PathBuf};
+
+use serde::Deserialize;
+
+use crate::{
+    fomod::{FileType, FileTypeEnum},
+    utils::walk_all_files,
+};
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+pub struct ModFile {
+    /// Relative path in the mod
+    src: PathBuf,
+
+    /// Relative path on where to install file in game dir
+    dst: PathBuf,
+
+    /// Internal priority inside the mod itself. In case the mod overwrites internal files.
+    internal_priority: isize,
+}
+
+impl ModFile {
+    pub fn new(src: impl AsRef<Path>, dst: impl AsRef<Path>, prio: isize) -> Self {
+        Self {
+            src: src.as_ref().to_owned(),
+            dst: dst.as_ref().to_owned(),
+            internal_priority: prio,
+        }
+    }
+
+    pub fn new_from_installer(file: FileType) -> Self {
+        let dest: PathBuf = file.destination.unwrap_or_default().into();
+
+        ModFile {
+            src: file.source.into(),
+            dst: dest.to_owned(),
+            internal_priority: file.priority.unwrap_or(0),
+        }
+    }
+
+    pub fn from_installer(
+        entry: FileTypeEnum,
+        source: impl AsRef<Path>,
+    ) -> Result<Vec<Self>, std::io::Error> {
+        match entry {
+            FileTypeEnum::File(file_type) => Ok(vec![Self::new_from_installer(file_type)]),
+            FileTypeEnum::Folder(dir_type) => {
+                let source_root = source.as_ref().join(&dir_type.source);
+                let priority = dir_type.priority.unwrap_or(0);
+                let dest_base: PathBuf =
+                    Path::new("Data").join(PathBuf::from(dir_type.destination.unwrap_or_default()));
+
+                let files = walk_all_files(&source_root)?
+                    .map(|entry| Self {
+                        src: entry.path().strip_prefix(&source).unwrap().to_owned(),
+                        dst: dest_base.join(entry.path().strip_prefix(&source_root).unwrap()),
+                        internal_priority: priority,
+                    })
+                    .collect();
+
+                Ok(files)
+            }
+        }
+    }
+
+    pub fn src(&self) -> &Path {
+        &self.src
+    }
+
+    /// Get the realtive path this file should be installed
+    pub fn dst(&self) -> &Path {
+        &self.dst
+    }
+
+    /// Get the iternal priority. Only used when 2 files conflict.
+    #[inline]
+    pub fn internal_priority(&self) -> isize {
+        self.internal_priority
+    }
+}

src/types/modded_instance.rs

@@ -0,0 +1,161 @@
+use std::{
+    ffi::OsStr,
+    fs::{self, read_to_string},
+    io::Write,
+    path::{Path, PathBuf},
+};
+
+use log::debug;
+use serde::{Deserialize, Serialize};
+
+use crate::types::{ConfigReadWriteError, installed_mod::InstalledMod, link::Link};
+
+/// An modded game with all plugins and files
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ModdedInstance {
+    game: String,
+
+    #[serde(default)]
+    mods: Vec<InstalledMod>,
+
+    #[serde(default)]
+    load_order: Vec<String>,
+
+    #[serde(default)]
+    game_file_overrides: Vec<Link>,
+
+    #[serde(skip)]
+    self_path: PathBuf,
+}
+
+impl ModdedInstance {
+    pub fn new(
+        game: &str,
+        mods: &[InstalledMod],
+        load_order: &[String],
+        overrides: &[Link],
+        self_path: impl AsRef<Path>,
+    ) -> Self {
+        Self {
+            game: game.to_owned(),
+            mods: mods.to_owned(),
+            load_order: load_order.to_owned(),
+            game_file_overrides: overrides.to_owned(),
+            self_path: self_path.as_ref().to_owned(),
+        }
+    }
+
+    pub fn load_from_file(path: impl AsRef<Path>) -> Result<Self, ConfigReadWriteError> {
+        debug!(
+            "Loading ModdedInstance from file: {}",
+            path.as_ref().to_string_lossy()
+        );
+
+        let data = read_to_string(&path)?;
+        let mut config: Self = toml::from_str(&data)?;
+
+        config.self_path = path.as_ref().to_owned();
+
+        Ok(config)
+    }
+
+    pub fn save_to_file(&self) -> Result<(), ConfigReadWriteError> {
+        debug!(
+            "Saving ModdedInstance to: {}",
+            self.self_path.to_string_lossy()
+        );
+
+        let content = toml::to_string_pretty(self)?;
+        let mut file = fs::File::create(&self.self_path)?;
+        write!(file, "{}", content)?;
+        Ok(())
+    }
+
+    pub fn set_load_order(&mut self, order: Vec<String>) {
+        self.load_order = order;
+    }
+
+    pub fn load_order(&self) -> &[String] {
+        &self.load_order
+    }
+
+    pub fn game_file_overrides(&self) -> &[Link] {
+        &self.game_file_overrides
+    }
+
+    pub fn update_or_create_mod(&mut self, installed_mod: &InstalledMod) {
+        match self
+            .mods
+            .iter_mut()
+            .find(|e| e.mod_id() == installed_mod.mod_id())
+        {
+            Some(existing) => {
+                *existing = installed_mod.to_owned();
+            }
+            None => {
+                self.mods.push(installed_mod.to_owned());
+            }
+        }
+    }
+
+    pub fn game_id(&self) -> &str {
+        &self.game
+    }
+
+    pub fn mods(&self) -> &[InstalledMod] {
+        &self.mods
+    }
+
+    pub fn active_plugins(&self) -> impl Iterator<Item = &OsStr> {
+        self.mods.iter().flat_map(|e| e.active_plugins())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_config() -> ModdedInstance {
+        ModdedInstance::new(
+            "sse",
+            &[InstalledMod::new("mod1", 0), InstalledMod::new("mod1", 0)],
+            &["Plugin1.esp".to_owned(), "Plugin2.esp".to_owned()],
+            &[Link::new("file1.txt", "file2.txt")],
+            "/config/instance.toml",
+        )
+    }
+
+    #[test]
+    fn basic_members() {
+        let cfg = create_config();
+
+        assert_eq!(cfg.game_file_overrides().len(), 1);
+        assert_eq!(cfg.mods().len(), 2);
+        assert_eq!(cfg.load_order().len(), 2);
+    }
+
+    #[test]
+    fn add_mod() {
+        let mut cfg = create_config();
+
+        let new_mod = InstalledMod::new("mod3", 1);
+
+        cfg.update_or_create_mod(&new_mod);
+
+        let mods = cfg.mods();
+        assert_eq!(mods.len(), 3);
+
+        let found_mod = mods.iter().find(|e| e.mod_id() == "mod3");
+
+        assert!(found_mod.is_some());
+    }
+
+    #[test]
+    fn update_mod() {
+        let mut cfg = create_config();
+        let new_mod = InstalledMod::new("mod1", 1);
+
+        cfg.update_or_create_mod(&new_mod);
+
+    }
+}

src/types/nexus_id.rs

@@ -0,0 +1,70 @@
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::str::FromStr;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct NexusID {
+    mod_id: u64,
+    file_id: u64,
+}
+
+impl NexusID {
+    pub fn new(mod_id: u64, file_id: u64) -> Self {
+        Self { mod_id, file_id }
+    }
+}
+
+impl Serialize for NexusID {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let s = format!("{}:{}", self.mod_id, self.file_id);
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for NexusID {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let mut parts = s.split(':');
+
+        let mod_id = parts
+            .next()
+            .ok_or_else(|| serde::de::Error::custom("missing first value"))
+            .and_then(|p| u64::from_str(p).map_err(serde::de::Error::custom))?;
+
+        let file_id = parts
+            .next()
+            .ok_or_else(|| serde::de::Error::custom("missing second value"))
+            .and_then(|p| u64::from_str(p).map_err(serde::de::Error::custom))?;
+
+        if parts.next().is_some() {
+            return Err(serde::de::Error::custom("too many parts"));
+        }
+
+        Ok(Self { mod_id, file_id })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Deserialize, Serialize, PartialEq, Debug)]
+    struct Wrapper {
+        value: NexusID,
+    }
+
+    #[test]
+    fn serde_roundtrip() {
+        let val = Wrapper {
+            value: NexusID::new(1234, 5678),
+        };
+        let serialized = toml::to_string(&val).unwrap();
+        let deserialized: Wrapper = toml::from_str(&serialized).unwrap();
+        assert_eq!(val, deserialized);
+    }
+}

src/types/root_config.rs

@@ -0,0 +1,270 @@
+use std::{
+    collections::HashMap,
+    fs::{self, read_to_string},
+    io::Write,
+    path::{Path, PathBuf},
+};
+
+use log::debug;
+use serde::{Deserialize, Serialize};
+
+use crate::types::{ConfigReadWriteError, ModConfig, game::Game, modded_instance::ModdedInstance};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct RootConfig {
+    #[serde(default)]
+    games: HashMap<String, Game>,
+
+    mod_location: PathBuf,
+
+    download_location: Option<PathBuf>,
+
+    nexus_api_key: Option<String>,
+
+    #[serde(default)]
+    instances: HashMap<String, InstancePointer>,
+
+    /// All available mods
+    #[serde(default)]
+    mods: HashMap<String, ModConfig>,
+
+    #[serde(skip)]
+    self_path: PathBuf,
+
+    #[serde(skip)]
+    self_parent: PathBuf,
+}
+
+impl RootConfig {
+    pub fn load_from_file(path: impl AsRef<Path>) -> Result<Self, ConfigReadWriteError> {
+        debug!(
+            "Loading RootConfig from file: {}",
+            path.as_ref().to_string_lossy()
+        );
+
+        let data = read_to_string(&path)?;
+        let mut config: Self = toml::from_str(&data)?;
+
+        let absolute = fs::canonicalize(path.as_ref())?;
+        config.self_parent = absolute
+            .parent()
+            .ok_or(ConfigReadWriteError::NoParent)?
+            .to_owned();
+        config.self_path = absolute;
+
+        Ok(config)
+    }
+
+    pub fn save_to_file(&self) -> Result<(), ConfigReadWriteError> {
+        debug!(
+            "Saving root_config to: {}",
+            self.self_path.to_string_lossy()
+        );
+        let content = toml::to_string_pretty(self)?;
+        let mut file = fs::File::create(&self.self_path)?;
+        write!(file, "{}", content)?;
+        Ok(())
+    }
+
+    pub fn game_by_id(&self, id: &str) -> Option<Game> {
+        self.games.get(id).map(|parsed_game| {
+            if parsed_game.install_location().is_relative() {
+                let abs_path = self.self_parent.join(parsed_game.install_location());
+                debug!(
+                    "game path for {} is relative. Resolving to {}",
+                    id,
+                    abs_path.to_string_lossy()
+                );
+                Game::new(abs_path, parsed_game.game_type())
+            } else {
+                parsed_game.clone()
+            }
+        })
+    }
+
+    pub fn mod_by_id(&self, id: &str) -> Option<ModConfig> {
+        self.mods.get(id).map(|e| e.clone().add_id(id))
+    }
+
+    pub fn add_mod(&mut self, new_mod: &ModConfig) {
+        self.mods.insert(new_mod.id().to_owned(), new_mod.clone());
+    }
+
+    pub fn load_instance_by_id(&self, id: &str) -> Result<ModdedInstance, ConfigReadWriteError> {
+        debug!("Loading instance {}", id);
+        let conf = self
+            .instances
+            .get(id)
+            .ok_or(ConfigReadWriteError::IDNotFound)?;
+
+        if conf.path.is_relative() {
+            let abs_path = self.self_parent.join(&conf.path);
+            debug!(
+                "instance path is relative. Resolving to {}",
+                abs_path.to_string_lossy()
+            );
+            ModdedInstance::load_from_file(abs_path)
+        } else {
+            ModdedInstance::load_from_file(&conf.path)
+        }
+    }
+
+    pub fn mod_location(&self) -> PathBuf {
+        if self.mod_location.is_relative() {
+            let abs_path = self.self_parent.join(&self.mod_location);
+            debug!(
+                "mod_location path is relative. Resolving to {}",
+                abs_path.to_string_lossy()
+            );
+            abs_path
+        } else {
+            self.mod_location.clone()
+        }
+    }
+
+    pub fn nexus_api_key(&self) -> Option<&str> {
+        self.nexus_api_key.as_deref()
+    }
+
+    pub fn download_location(&self) -> Option<PathBuf> {
+        self.download_location.as_ref().map(|e| {
+            if e.is_relative() {
+                let abs_path = self.self_parent.join(e);
+                debug!(
+                    "download_location path is relative. Resolving to {}",
+                    abs_path.to_string_lossy()
+                );
+                abs_path
+            } else {
+                e.clone()
+            }
+        })
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+struct InstancePointer {
+    path: PathBuf,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::types::GameType;
+
+    use super::*;
+
+    fn create_config() -> RootConfig {
+        RootConfig {
+            games: HashMap::from([(
+                "sse".to_owned(),
+                Game::new("/games/sse", GameType::SkyrimSE),
+            )]),
+            mod_location: PathBuf::from("mods"),
+            download_location: Some(PathBuf::from("download")),
+            nexus_api_key: Some("1234".to_owned()),
+            instances: HashMap::from([(
+                "instance1".to_owned(),
+                InstancePointer {
+                    path: PathBuf::from("instances/instance1.toml"),
+                },
+            )]),
+            mods: HashMap::from([(
+                "mod1".to_owned(),
+                ModConfig::new("mod1", PathBuf::from("mod1")),
+            )]),
+            self_path: PathBuf::from("/config/root.toml"),
+            self_parent: PathBuf::from("/config"),
+        }
+    }
+
+    #[test]
+    fn get_game() {
+        let cfg = create_config();
+
+        let game = cfg.game_by_id("sse");
+
+        assert!(game.is_some());
+
+        let unwraped = game.expect("Asserted before");
+        assert_eq!(unwraped.install_location(), "/games/sse");
+        assert_eq!(unwraped.game_type(), GameType::SkyrimSE);
+    }
+
+    #[test]
+    fn get_missing_game() {
+        let cfg = create_config();
+
+        let game = cfg.game_by_id("starfield");
+
+        assert!(game.is_none());
+    }
+
+    #[test]
+    fn get_mod() {
+        let cfg = create_config();
+
+        let found_mod = cfg.mod_by_id("mod1");
+
+        assert!(found_mod.is_some());
+
+        let unwraped = found_mod.expect("Asserted before");
+        assert_eq!(unwraped.path(), "mod1");
+    }
+
+    #[test]
+    fn get_missing_mod() {
+        let cfg = create_config();
+
+        let found_mod = cfg.mod_by_id("mod200");
+
+        assert!(found_mod.is_none());
+    }
+
+    #[test]
+    fn get_api_key() {
+        let cfg = create_config();
+
+        assert_eq!(cfg.nexus_api_key(), Some("1234"));
+    }
+
+    #[test]
+    fn get_download_location() {
+        let cfg = create_config();
+
+        let dl = cfg.download_location();
+
+        assert!(dl.is_some());
+
+        let unwraped = dl.expect("Asserted before");
+
+        assert!(unwraped.is_absolute(), "Path not absolute");
+        assert_eq!(unwraped, PathBuf::from("/config/download"));
+    }
+
+    #[test]
+    fn get_mod_location() {
+        let cfg = create_config();
+
+        let mod_dir = cfg.mod_location();
+
+        assert!(mod_dir.is_absolute(), "Path not absolute");
+        assert_eq!(mod_dir, PathBuf::from("/config/mods"));
+    }
+
+    #[test]
+    fn add_mod() {
+        let mut cfg = create_config();
+
+        let new_mod = ModConfig::new("new_mod", "new_mod_path");
+
+        cfg.add_mod(&new_mod);
+
+        let found_mod = cfg.mod_by_id("new_mod");
+
+        assert!(found_mod.is_some());
+        let unwraped = found_mod.expect("Asserted before");
+
+        assert_eq!(unwraped.path(), new_mod.path());
+    }
+}

src/unpacker.rs

@@ -0,0 +1,104 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use anyhow::{Ok, anyhow};
+use log::error;
+use zip::ZipArchive;
+
+pub fn unpack(archive_path: impl AsRef<Path>, extract_to: impl AsRef<Path>) -> anyhow::Result<()> {
+    if fs::exists(&extract_to)? {
+        return Err(anyhow!(
+            "File already exists: {}",
+            extract_to.as_ref().to_string_lossy()
+        ));
+    }
+
+    match archive_path.as_ref().extension().and_then(|e| e.to_str()) {
+        Some("7z") => unpack_7z_file(archive_path, &extract_to),
+        Some("zip") => unpack_zip_file(archive_path, &extract_to),
+        Some("rar") => unpack_rar(archive_path, &extract_to),
+        Some(ext) => {
+            error!("Unsupported archive format: {}", ext);
+            Err(anyhow!("Unsupported archive format: {}", ext))
+        }
+        None => {
+            error!(
+                "Failed to determine the file extension for {}",
+                &archive_path.as_ref().to_string_lossy()
+            );
+            Err(anyhow!("Failed to determine file extension"))
+        }
+    }?;
+
+    unnest_dir(extract_to)?;
+
+    Ok(())
+}
+
+fn unpack_7z_file(path: impl AsRef<Path>, to: impl AsRef<Path>) -> anyhow::Result<()> {
+    sevenz_rust2::decompress_file(path, to)?;
+    Ok(())
+}
+
+fn unpack_zip_file(path: impl AsRef<Path>, to: impl AsRef<Path>) -> anyhow::Result<()> {
+    let file = fs::File::open(path)?;
+    let mut archive = ZipArchive::new(file)?;
+    archive.extract(to)?;
+    Ok(())
+}
+
+fn unpack_rar(path: impl AsRef<Path>, to: impl AsRef<Path>) -> anyhow::Result<()> {
+    let mut archive = unrar::Archive::new(path.as_ref()).open_for_processing()?;
+
+    while let Some(header) = archive.read_header()? {
+        archive = header.extract_with_base(&to)?;
+    }
+
+    Ok(())
+}
+
+/// Moves a directorys content into the parent if it is the only dir
+fn unnest_dir(path: impl AsRef<Path>) -> anyhow::Result<()> {
+    let path = path.as_ref();
+
+    let Some(nested_dir) = check_nested_dir(path) else {
+        return Ok(());
+    };
+
+    for entry in fs::read_dir(&nested_dir)? {
+        let entry = entry?;
+        let src = entry.path();
+        let dest = path.join(entry.file_name());
+        fs::rename(&src, &dest)?;
+    }
+
+    fs::remove_dir(&nested_dir)?;
+    Ok(())
+}
+
+/// Check if the extracted archive has a single directory in it which contains the mod files
+fn check_nested_dir(path: impl AsRef<Path>) -> Option<PathBuf> {
+    let path = path.as_ref();
+
+    let entries: Vec<_> = fs::read_dir(path).ok()?.filter_map(|e| e.ok()).collect();
+
+    if entries.len() == 1 {
+        let entry = &entries[0];
+        let entry_path = entry.path();
+
+        if entry_path
+            .file_name()
+            .is_some_and(|e| e == "Data" || e == "data")
+        {
+            return None;
+        }
+
+        if entry_path.is_dir() {
+            return Some(entry_path);
+        }
+    }
+
+    None
+}

src/utils.rs

@@ -0,0 +1,66 @@
+use std::{
+    fs::{self},
+    io,
+    path::{Path, PathBuf},
+};
+
+use walkdir::WalkDir;
+
+pub fn path_to_lowercase(path: impl AsRef<Path>) -> PathBuf {
+    PathBuf::from(path.as_ref().to_string_lossy().to_lowercase())
+}
+
+/// Searches for a path but ignores case. Returns the first it finds.
+pub fn resolve_case_insensitive(
+    base: impl AsRef<Path>,
+    rel: impl AsRef<Path>,
+) -> io::Result<Option<PathBuf>> {
+    let mut current = base.as_ref().to_path_buf();
+
+    for part in rel.as_ref().iter() {
+        let target = part.to_string_lossy();
+
+        let mut found = None;
+
+        for entry in fs::read_dir(&current)? {
+            let entry = entry?;
+            let name = entry.file_name();
+            let name = name.to_string_lossy();
+
+            if name.eq_ignore_ascii_case(&target) {
+                found = Some(entry.path());
+                break;
+            }
+        }
+
+        match found {
+            Some(path) => current = path,
+            None => {
+                return Ok(None);
+            }
+        }
+    }
+
+    Ok(Some(current))
+}
+
+/// Use walkdir to walk all actual files in a dir
+/// Returns early if any error occurs
+pub fn walk_all_files(
+    path: impl AsRef<Path>,
+) -> Result<impl Iterator<Item = walkdir::DirEntry>, walkdir::Error> {
+    let a = WalkDir::new(path)
+        .into_iter()
+        .collect::<Result<Vec<_>, walkdir::Error>>()?
+        .into_iter()
+        .filter(|entry| entry.file_type().is_file());
+
+    Ok(a)
+}
+
+pub fn is_plugin_file(filename: impl AsRef<Path>) -> bool {
+    filename
+        .as_ref()
+        .extension()
+        .is_some_and(|ext| ext == "esp" || ext == "esm" || ext == "esl")
+}

tests/add_mod_test.rs

@@ -0,0 +1,144 @@
+use std::{collections::HashSet, error::Error, path::PathBuf};
+
+use fomod_manager::{
+    actions::{insert_mod_to_instance, resolve_files_for_install},
+    types::{Link, RootConfig},
+};
+
+fn get_parent() -> PathBuf {
+    PathBuf::from(file!()).parent().unwrap().to_owned()
+}
+
+fn load_root() -> RootConfig {
+    RootConfig::load_from_file(get_parent().join("data/root_config_complex.toml")).unwrap()
+}
+
+#[test]
+fn add_plain() -> Result<(), Box<dyn Error>> {
+    let root_config = load_root();
+    let mut instance = root_config.load_instance_by_id("instance_minimal")?;
+    let mod_to_install = root_config
+        .mod_by_id("add_test_plain")
+        .expect("Mod not found");
+    let files_to_add = resolve_files_for_install(&root_config, &instance, &mod_to_install)?;
+
+    insert_mod_to_instance(&mut instance, &mod_to_install, &files_to_add, 0);
+
+    let installed_mods = instance.mods();
+
+    assert_eq!(installed_mods.len(), 1);
+
+    let the_mod = installed_mods.first().expect("Asserted before");
+
+    assert_eq!(the_mod.mod_id(), "add_test_plain");
+    assert_eq!(the_mod.priority(), 0);
+
+    let expected_files: HashSet<_> = [Link::new("plugin.esp", "Data/plugin.esp")]
+        .into_iter()
+        .collect();
+
+    assert_eq!(
+        *the_mod.files(),
+        expected_files,
+        "Installed files missmatch"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn add_nested() -> Result<(), Box<dyn Error>> {
+    let root_config = load_root();
+    let mut instance = root_config.load_instance_by_id("instance_minimal")?;
+    let mod_to_install = root_config
+        .mod_by_id("add_test_nested")
+        .expect("Mod not found");
+    let files_to_add = resolve_files_for_install(&root_config, &instance, &mod_to_install)?;
+
+    insert_mod_to_instance(&mut instance, &mod_to_install, &files_to_add, 0);
+
+    let installed_mods = instance.mods();
+
+    assert_eq!(installed_mods.len(), 1);
+
+    let the_mod = installed_mods.first().expect("Asserted before");
+
+    assert_eq!(the_mod.mod_id(), "add_test_nested");
+    assert_eq!(the_mod.priority(), 0);
+
+    let expected_files: HashSet<_> = [Link::new("Data/plugin.esp", "Data/plugin.esp")]
+        .into_iter()
+        .collect();
+
+    assert_eq!(
+        *the_mod.files(),
+        expected_files,
+        "Installed files missmatch"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn add_root() -> Result<(), Box<dyn Error>> {
+    let root_config = load_root();
+    let mut instance = root_config.load_instance_by_id("instance_minimal")?;
+    let mod_to_install = root_config
+        .mod_by_id("add_test_root")
+        .expect("Mod not found");
+    let files_to_add = resolve_files_for_install(&root_config, &instance, &mod_to_install)?;
+
+    insert_mod_to_instance(&mut instance, &mod_to_install, &files_to_add, 0);
+
+    let installed_mods = instance.mods();
+
+    assert_eq!(installed_mods.len(), 1, "No mod was added");
+
+    let the_mod = installed_mods.first().expect("Asserted before");
+
+    assert_eq!(the_mod.mod_id(), "add_test_root");
+    assert_eq!(the_mod.priority(), 0);
+
+    let expected_files: HashSet<_> = [Link::new("skse.exe", "skse.exe")].into_iter().collect();
+
+    assert_eq!(
+        *the_mod.files(),
+        expected_files,
+        "Installed files missmatch"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn add_filter() -> Result<(), Box<dyn Error>> {
+    let root_config = load_root();
+    let mut instance = root_config.load_instance_by_id("instance_minimal")?;
+    let mod_to_install = root_config
+        .mod_by_id("add_test_filter")
+        .expect("Mod not found");
+    let files_to_add = resolve_files_for_install(&root_config, &instance, &mod_to_install)?;
+
+    insert_mod_to_instance(&mut instance, &mod_to_install, &files_to_add, 0);
+
+    let installed_mods = instance.mods();
+
+    assert_eq!(installed_mods.len(), 1, "No mod was added");
+
+    let the_mod = installed_mods.first().expect("Asserted before");
+
+    assert_eq!(the_mod.mod_id(), "add_test_filter");
+    assert_eq!(the_mod.priority(), 0);
+
+    let expected_files: HashSet<_> = [Link::new("plugin.esp", "plugin.esp")]
+        .into_iter()
+        .collect();
+
+    assert_eq!(
+        *the_mod.files(),
+        expected_files,
+        "Installed files missmatch"
+    );
+
+    Ok(())
+}

tests/data/fomod/moduleconfig/banana.xml

@@ -0,0 +1,88 @@
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+    <moduleName>The BANANA Mod</moduleName>
+    <moduleImage path="fomod\images\banana.jpg" />
+
+    <installSteps>
+        <installStep name="THE FIRST OF MANY STEPS">
+            <optionalFileGroups order="Explicit">
+
+
+                <group name="Banana Types" type="SelectAny">
+                    <plugins order="Explicit">
+
+                        <plugin name="1700s">
+                            <description>Bananas from the 1700s were vastly different from what we see on the shelves today!</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="Required" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Australian">
+                            <description>Nobody knows why, but Australia has some WEIRD bananas.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="Recommended" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Modern Worldwide">
+                            <description>Ah, the modern Cavendish banana! How not-sweet it tastes! Do yourself a favor and get one from the 1700s.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="Optional" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Purple Bananas">
+                            <description>~~CENSORED~~</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="CouldBeUsable" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Brown Bananas">
+                            <description>Sorry, but you can't have feces.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="NotUsable" /></typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+
+                
+                <group name="Banana Textures" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <plugin name="Base 1024x1024">
+                            <description>These textures are used for anything we didn't downscale/upscale.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="Required" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="2048x2048">
+                            <description>2K is a comfortable resolution fot banana textures.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="Recommended" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="4096x4096">
+                            <description>4K might be a bit over the top, but hey.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="Optional" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="128x128">
+                            <description>Looks awful.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="CouldBeUsable" /></typeDescriptor>
+                        </plugin>
+
+                        <plugin name="0x0">
+                            <description>Just... don't install the mod.</description>
+                            <conditionFlags><flag name="1">1</flag></conditionFlags>
+                            <typeDescriptor><type name="NotUsable" /></typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+
+
+            </optionalFileGroups>
+        </installStep>
+    </installSteps>
+
+</config>

tests/data/fomod/moduleconfig/example_01.xml

@@ -0,0 +1,10 @@
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+
+    <moduleName>Example Mod</moduleName>
+
+    <requiredInstallFiles>
+        <file source="example.plugin"/>
+    </requiredInstallFiles>
+
+</config>

tests/data/fomod/moduleconfig/example_02.xml

@@ -0,0 +1,30 @@
+<!-- For this second example, let's make use of dependencies.
+     Before starting the installation, dependencies
+     make sure the things you specify are in place.
+     -->
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+
+    <moduleName>Example Mod</moduleName>
+
+    <!-- The "And" operator means that all dependencies
+         below this tag must be true for it to be true
+         as well. The other possible value is "Or".
+         -->
+    <moduleDependencies operator="And">
+        <fileDependency file="depend1.plugin" state="Active"/>
+        <dependencies operator="Or">
+            <fileDependency file="depend2v1.plugin" state="Active"/>
+            <fileDependency file="depend2v2.plugin" state="Active"/>
+        </dependencies>
+    </moduleDependencies>
+
+    <!-- Now before installing our lovely and empty
+         data file in requiredInstallFiles,
+         we need to make sure a few other plugins exist
+         -->
+    <requiredInstallFiles>
+        <file source="example.plugin"/>
+    </requiredInstallFiles>
+
+</config>

tests/data/fomod/moduleconfig/example_03.xml

@@ -0,0 +1,86 @@
+<!-- On the third example, we'll take a look at using
+     install steps to let users choose what to install
+     -->
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+
+    <moduleName>Example Mod</moduleName>
+
+    <moduleDependencies operator="And">
+        <fileDependency file="depend1.plugin" state="Active"/>
+        <dependencies operator="Or">
+            <fileDependency file="depend2v1.plugin" state="Active"/>
+            <fileDependency file="depend2v2.plugin" state="Active"/>
+        </dependencies>
+    </moduleDependencies>
+
+    <!-- We'll no longer be using "requiredInstallFiles"
+         since we can now offer a choice between files
+         -->
+    <installSteps order="Explicit">
+        <installStep name="Choose Option">
+
+            <!-- In 99.9% of cases you'll want to set
+                 the 'order' attribute in "installSteps",
+                 "optionalFileGroups" and "plugins" to
+                 'Explicit'
+                 -->
+            <optionalFileGroups order="Explicit">
+
+                <!-- This tag collects options into separate
+                     groups - useful if you want to have multiple
+                     types of choices for the user in a single
+                     step
+                     -->
+                <group name="Select an option:" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <!-- Each "plugin" tag represents a choice
+                             the user can make.
+                             -->
+                        <plugin name="Option A">
+
+                            <description>Select this to install Option A!</description>
+
+                            <!-- Optional but recommended
+                                 -->
+                            <image path="fomod/option_a.png"/>
+
+                            <!-- The files/folders to install
+                                 -->
+                            <files>
+                                <folder source="option_a"/>
+                            </files>
+
+                            <!-- This describes what type the plugin is.
+                                 Most likely you'll choose between:
+                                 - 'Optional'
+                                 - 'Required'
+                                 - 'Recommended'
+                                 -->
+                            <typeDescriptor>
+                                <type name="Recommended"/>
+                            </typeDescriptor>
+
+                        </plugin>
+
+                        <plugin name="Option B">
+                            <description>Select this to install Option B!</description>
+                            <image path="fomod/option_b.png"/>
+                            <files>
+                                <folder source="option_b"/>
+                            </files>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+
+            </optionalFileGroups>
+
+        </installStep>
+    </installSteps>
+
+</config>

tests/data/fomod/moduleconfig/example_04.xml

@@ -0,0 +1,141 @@
+<!-- This time we'll take a look at multiple step
+     installs - flags and visiblity
+     -->
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+
+    <moduleName>Example Mod</moduleName>
+
+    <moduleDependencies operator="And">
+        <fileDependency file="depend1.plugin" state="Active"/>
+        <dependencies operator="Or">
+            <fileDependency file="depend2v1.plugin" state="Active"/>
+            <fileDependency file="depend2v2.plugin" state="Active"/>
+        </dependencies>
+    </moduleDependencies>
+
+    <installSteps order="Explicit">
+
+        <installStep name="Choose Option">
+            <optionalFileGroups order="Explicit">
+                <group name="Select an option:" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <plugin name="Option A">
+                            <description>Select this to install Option A!</description>
+                            <image path="fomod/option_a.png"/>
+                            <files>
+                                <folder source="option_a"/>
+                            </files>
+                            <!-- conditionFlags and files have interchangeable
+                                 order and at least one of them needs to be
+                                 present.
+
+                                 conditionFlags sets flags whenever this plugin
+                                 is selected.
+                                 -->
+                            <conditionFlags>
+                                <flag name="option_a">selected</flag>
+                            </conditionFlags>
+                            <typeDescriptor>
+                                <type name="Recommended"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Option B">
+                            <description>Select this to install Option B!</description>
+                            <image path="fomod/option_b.png"/>
+                            <files>
+                                <folder source="option_b"/>
+                            </files>
+                            <conditionFlags>
+                                <flag name="option_b">selected</flag>
+                            </conditionFlags>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+            </optionalFileGroups>
+        </installStep>
+
+        <installStep name="Choose Texture">
+            <!-- visible is a dependencies network that lets this
+                 step appear only when it's conditions are met.
+
+                 If they're not met, this step is skipped.
+                 -->
+            <visible>
+                <flagDependency flag="option_a" value="selected"/>
+            </visible>
+            <optionalFileGroups order="Explicit">
+                <group name="Select a texture:" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <plugin name="Texture Blue">
+                            <description>Select this to install Texture Blue!</description>
+                            <image path="fomod/texture_blue.png"/>
+                            <files>
+                                <folder source="texture_blue_a"/>
+                            </files>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Texture Red">
+                            <description>Select this to install Texture Red!</description>
+                            <image path="fomod/texture_red.png"/>
+                            <files>
+                                <folder source="texture_red_a"/>
+                            </files>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+            </optionalFileGroups>
+        </installStep>
+
+        <installStep name="Choose Texture">
+            <visible>
+                <flagDependency flag="option_b" value="selected"/>
+            </visible>
+            <optionalFileGroups order="Explicit">
+                <group name="Select a texture:" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <plugin name="Texture Blue">
+                            <description>Select this to install Texture Blue!</description>
+                            <image path="fomod/texture_blue.png"/>
+                            <files>
+                                <folder source="texture_blue_b"/>
+                            </files>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Texture Red">
+                            <description>Select this to install Texture Red!</description>
+                            <image path="fomod/texture_red.png"/>
+                            <files>
+                                <folder source="texture_red_b"/>
+                            </files>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+            </optionalFileGroups>
+        </installStep>
+
+    </installSteps>
+
+</config>

tests/data/fomod/moduleconfig/example_05.xml

@@ -0,0 +1,133 @@
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+
+    <moduleName>Example Mod</moduleName>
+
+    <moduleDependencies operator="And">
+        <fileDependency file="depend1.plugin" state="Active"/>
+        <dependencies operator="Or">
+            <fileDependency file="depend2v1.plugin" state="Active"/>
+            <fileDependency file="depend2v2.plugin" state="Active"/>
+        </dependencies>
+    </moduleDependencies>
+
+    <installSteps order="Explicit">
+        <installStep name="Choose Option">
+            <optionalFileGroups order="Explicit">
+
+                <group name="Select an option:" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <plugin name="Option A">
+                            <description>Select this to install Option A!</description>
+                            <image path="fomod/option_a.png"/>
+                            <conditionFlags>
+                                <flag name="option_a">selected</flag>
+                            </conditionFlags>
+                            <typeDescriptor>
+                                <type name="Recommended"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Option B">
+                            <description>Select this to install Option B!</description>
+                            <image path="fomod/option_b.png"/>
+                            <conditionFlags>
+                                <flag name="option_b">selected</flag>
+                            </conditionFlags>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+
+                <!-- Since we're installing everything in
+                     conditionalFileInstalls we're free to
+                     make all selections in a single step.
+                     -->
+                <group name="Select a texture:" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+
+                        <plugin name="Texture Blue">
+                            <description>Select this to install Texture Blue!</description>
+                            <image path="fomod/texture_blue.png"/>
+                            <conditionFlags>
+                                <flag name="texture_blue">selected</flag>
+                            </conditionFlags>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                        <plugin name="Texture Red">
+                            <description>Select this to install Texture Red!</description>
+                            <image path="fomod/texture_red.png"/>
+                            <conditionFlags>
+                                <flag name="texture_red">selected</flag>
+                            </conditionFlags>
+                            <typeDescriptor>
+                                <type name="Optional"/>
+                            </typeDescriptor>
+                        </plugin>
+
+                    </plugins>
+                </group>
+
+            </optionalFileGroups>
+        </installStep>
+    </installSteps>
+
+    <!-- This is where we're installing everything.
+         -->
+    <conditionalFileInstalls>
+        <patterns>
+            <!-- Each pattern is a piece of the matrix
+                 eseentially linking a set of dependencies
+                 to a set of files to install.
+                 -->
+            <pattern>
+                <dependencies operator="And">
+                    <flagDependency flag="option_a" value="selected"/>
+                    <flagDependency flag="texture_blue" value="selected"/>
+                </dependencies>
+                <files>
+                    <folder source="option_a"/>
+                    <folder source="texture_blue_a"/>
+                </files>
+            </pattern>
+            <pattern>
+                <dependencies operator="And">
+                    <flagDependency flag="option_a" value="selected"/>
+                    <flagDependency flag="texture_red" value="selected"/>
+                </dependencies>
+                <files>
+                    <folder source="option_a"/>
+                    <folder source="texture_red_a"/>
+                </files>
+            </pattern>
+            <pattern>
+                <dependencies operator="And">
+                    <flagDependency flag="option_b" value="selected"/>
+                    <flagDependency flag="texture_blue" value="selected"/>
+                </dependencies>
+                <files>
+                    <folder source="option_b"/>
+                    <folder source="texture_blue_b"/>
+                </files>
+            </pattern>
+            <pattern>
+                <dependencies operator="And">
+                    <flagDependency flag="option_b" value="selected"/>
+                    <flagDependency flag="texture_red" value="selected"/>
+                </dependencies>
+                <files>
+                    <folder source="option_b"/>
+                    <folder source="texture_red_b"/>
+                </files>
+            </pattern>
+        </patterns>
+    </conditionalFileInstalls>
+
+</config>

tests/data/fomod/moduleconfig/ineed.xml

@@ -0,0 +1,118 @@
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+	<moduleName>iNeed - Food, Water and Sleep - Continued</moduleName>
+	<installSteps order="Explicit">		
+		<installStep name="Options">
+			<optionalFileGroups>
+				<group name="0. Core" type="SelectAny">
+					<plugins order="Explicit">
+						<plugin name="Core Files">
+							<description>
+								Contains the main mod.
+							</description>
+							<image path="FOMod\screenshot.jpg"/>
+							<files>
+								<folder source="00 Core" destination="" priority="0"/>
+							</files>
+							<typeDescriptor>
+								<type name="Required"/>
+							</typeDescriptor>
+						</plugin>
+					</plugins>
+				</group>
+				<group name="1. Extended" type="SelectExactlyOne">
+					<plugins order="Explicit">
+						<plugin name="Full | Requires AE and Creation Club Fishing">
+							<description>
+								Requires AE and Creation Club Fishing. This option is not compatible with other mods that modify vanilla food, recipes and with 'Survival' mode! Enables snow collection from medium to large exterior snow drifts simply by activating them. Removes magic effect buffs and debuffs from most food and drink items. Removes the Salt Pile ingredient from cooked meat. Rebalances soup recipes by adding a water ingredient requirement and by changing the number of soups produced from 1 to 2. Innkeepers will now sometimes sell soups and Hearthfire foods.
+							</description>
+							<image path="FOMod\extended.jpg"/>
+							<files>
+								<folder source="01 Extended" destination="" priority="1"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="No Food Changes | Requires AE and Creation Club Fishing">
+							<description>
+								Requires AE and Creation Club Fishing. This option is not compatible with other mods that modify vanilla recipes and with 'Survival' mode! Enables snow collection from medium to large exterior snow drifts simply by activating them. Removes the Salt Pile ingredient from cooked meat. Rebalances soup recipes by adding a water ingredient requirement and by changing the number of soups produced from 1 to 2. Innkeepers will now sometimes sell soups and Hearthfire foods.
+							</description>
+							<image path="FOMod\extended.jpg"/>
+							<files>
+								<folder source="02 Extended - No Food" destination="" priority="1"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="No Food / No Recipe Changes | Requires AE and Creation Club Fishing">
+							<description>
+								Requires AE and Creation Club Fishing. Enables snow collection from medium to large exterior snow drifts simply by activating them. This option is compatible with all other mods that change "vanilla" cooking recipes, such as CACO or Cooking Expanded. Install it if such mods are installed, for better compatibility with iNeed.
+							</description>
+							<image path="FOMod\extended.jpg"/>
+							<files>
+								<folder source="03 Extended - No Food - No Recipes" destination="" priority="1"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="None">
+							<description>
+								iNeed - Extended will not be installed.
+							</description>
+							<image path="FOMod\extended.jpg"/>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+					</plugins>
+				</group>
+				<group name="2. Compatibility" type="SelectAny">
+					<plugins order="Explicit">
+						<plugin name="Nordic Snow">
+							<description>
+								Select this option if you have any version of iNeed - Extended installed along with Nordic Snow. This patch will match up the snow drift textures with the rest of the landscape modified by Nordic Snow.
+							</description>
+							<image path="FOMod\snow.jpg"/>
+							<files>
+								<folder source="10 Nordic Snow" destination="" priority="1"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="NobleSkyrimMod">
+							<description>
+								Select this option if you have any version of iNeed - Extended installed along with NobleSkyrimMod. This patch will match up the snow drift textures with the rest of the landscape modified by NobleSkyrimMod.
+							</description>
+							<image path="FOMod\snow.jpg"/>
+							<files>
+								<folder source="11 NobleSkyrimMod" destination="" priority="1"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+					</plugins>
+				</group>
+				<group name="Optionals" type="SelectAny">
+					<plugins order="Explicit">
+						<plugin name="Dangerous Diseases">
+							<description>
+								All non-transformative diseases will be more unique, harder to cure and progress through 4 deadlier stages at random intervals. See mod description for more information.
+							</description>
+							<image path="FOMod\disease.jpg"/>
+							<files>
+								<folder source="12 Dangerous Diseases Converted" destination="" priority="1"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+					</plugins>
+				</group>
+			</optionalFileGroups>
+		</installStep>
+	</installSteps>
+</config>

tests/data/fomod/moduleconfig/po3tweaks.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+    <moduleName>powerofthree's Tweaks</moduleName>
+    <requiredInstallFiles>
+        <folder source="Required" destination="" />
+    </requiredInstallFiles>
+    <installSteps order="Explicit">
+        <installStep name="Main">
+            <optionalFileGroups order="Explicit">
+                <group name="DLL" type="SelectExactlyOne">
+                    <plugins order="Explicit">
+                        <plugin name="SSE v1.6.629+ (&quot;Anniversary Edition&quot;)">
+                            <description>Select this if you are using Skyrim Anniversary Edition v1.6.629 or higher.</description>
+                            <files>
+                                <folder source="AE/SKSE/Plugins" destination="SKSE/Plugins" priority="0" />
+                            </files>
+                            <typeDescriptor>
+                                <dependencyType>
+                                    <defaultType name="Optional" />
+                                    <patterns>
+                                        <pattern>
+                                            <dependencies>
+                                                <gameDependency version="1.6" />
+                                            </dependencies>
+                                            <type name="Recommended" />
+                                        </pattern>
+                                        <pattern>
+                                            <dependencies>
+                                                <gameDependency version="1.5" />
+                                            </dependencies>
+                                            <type name="Optional" />
+                                        </pattern>
+                                    </patterns>
+                                </dependencyType>
+                            </typeDescriptor>
+                        </plugin>
+                        <plugin name="SSE v1.5.97 (&quot;Special Edition&quot;)">
+                            <description>Select this if you are using Skyrim Special Edition v1.5.97.</description>
+                            <files>
+                                <folder source="SE/SKSE/Plugins" destination="SKSE/Plugins" priority="0" />
+                            </files>
+                            <typeDescriptor>
+                                <dependencyType>
+                                    <defaultType name="Optional" />
+                                    <patterns>
+                                        <pattern>
+                                            <dependencies>
+                                                <gameDependency version="1.6" />
+                                            </dependencies>
+                                            <type name="Optional" />
+                                        </pattern>
+                                        <pattern>
+                                            <dependencies>
+                                                <gameDependency version="1.5" />
+                                            </dependencies>
+                                            <type name="Recommended" />
+                                        </pattern>
+                                    </patterns>
+                                </dependencyType>
+                            </typeDescriptor>
+                        </plugin>
+                    </plugins>
+                </group>
+            </optionalFileGroups>
+        </installStep>
+    </installSteps>
+</config>

tests/data/fomod/moduleconfig/starui.xml

@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+	<moduleName>StarUI Inventory</moduleName>
+	
+	<installSteps order="Explicit">
+	 
+	<installStep name="Select installation options">
+		<optionalFileGroups order="Explicit">
+			<group name="Main files" type="SelectAny">
+				<plugins order="Explicit">
+
+					<plugin name="StarUI Inventory">
+						<description>StarUI Inventory improves all inventory screens for use on a PC. Compact display style. More details in sortable columns. Item category icons. Category as left sidebar. Many quality of life features!</description>
+						<image path="fomod\images\StarUI Inventory Teaser.jpg" />
+						<files />
+						<typeDescriptor><type name="Required" /></typeDescriptor>
+					</plugin>
+				</plugins>
+			</group>
+
+			<group name="Mod Manager" type="SelectExactlyOne">
+				<plugins order='Explicit'>
+					<plugin name="Vortex">
+						<description>Select this if you use Vortex</description>
+						<image path="fomod\images\StarUI Inventory Teaser.jpg" />
+						<conditionFlags>
+							<flag name="flag_vortex">Active</flag>
+						</conditionFlags>
+						<files>
+							<folder source="Interface" destination="Data\Interface" />
+						</files>
+						<typeDescriptor><type name="Optional" /></typeDescriptor>
+					</plugin>
+					
+					<plugin name="Mod Organizer 2">
+						<description>Select this if you use Mod Organizer 2.</description>
+						<image path="fomod\images\StarUI Inventory Teaser.jpg" />
+						<conditionFlags>
+							<flag name="flag_mo2">Active</flag>
+						</conditionFlags>
+						<files>
+							<folder source="Interface" destination="Interface" />
+						</files>
+						<typeDescriptor><type name="Optional" /></typeDescriptor>
+					</plugin>
+				</plugins>
+			</group>
+
+
+			<group name="FPS (Frames Per Second)" type="SelectExactlyOne">
+				<plugins order='Explicit'>
+					<plugin name="30 FPS - Vanilla">
+						<description>Vanilla interface FPS. As like in the original game.</description>
+						<image path="fomod\images\StarUI Inventory Teaser.jpg" />
+						<conditionFlags>
+							<flag name="flag_30fps">Active</flag>
+						</conditionFlags>
+						<files />
+						<typeDescriptor><type name="Optional" /></typeDescriptor>
+					</plugin>
+					
+					<plugin name="60 FPS - Smooth and stable">
+						<description>Doubles the default interface FPS. Smoother and more responsive.</description>
+						<image path="fomod\images\StarUI Inventory Teaser.jpg" />
+						<conditionFlags>
+							<flag name="flag_60fps">Active</flag>
+						</conditionFlags>
+						<files />
+						<typeDescriptor><type name="Recommended" /></typeDescriptor>
+					</plugin>
+					
+					<plugin name="120 FPS - High-FPS (may cause crashes)">
+						<description>High-FPS version. This version needs an appropiate monitor to be used. &#xD;
+WARNING: Using 120FPS may cause the game to crash, as the game engine is not programmed for such high interface FPS rates.&#xD;
+&#xD;
+USE AT YOUR OWN RISK.&#xD;
+</description>
+						<image path="fomod\images\StarUI Inventory Teaser.jpg" />
+						<conditionFlags>
+							<flag name="flag_120fps">Active</flag>
+						</conditionFlags>
+						<files />
+						<typeDescriptor><type name="Optional" /></typeDescriptor>
+					</plugin>
+				</plugins>
+			</group>
+							
+		</optionalFileGroups>
+
+	</installStep>
+	
+	<installStep name="README">
+		<optionalFileGroups order="Explicit">
+			<group name="Please read the notes" type="SelectAny">
+				<plugins order="Explicit">
+					<plugin name="Requires Archive Invalidation">
+						<description>You will need to enable Archive Invalidation to load loose files.&#xD;
+If you haven't done that yet, see the mod page for detailed instructions.&#xD;</description>
+						<files />
+						<typeDescriptor>
+							<type name="Required" />
+						</typeDescriptor>
+					</plugin>
+								
+					<plugin name="INI: Settings, settings, settings">
+						<description>You can configure many different settings in the file Interface\StarUI Inventory.ini .&#xD;
+Every settings is described in the file, so you can easily adapt the whole mod to your liking.&#xD;</description>
+						<files />
+						<typeDescriptor>
+							<type name="Required" />
+						</typeDescriptor>
+					</plugin>
+					
+					<plugin name="Configuration done">
+						<description>Ready for installation.&#xD;
+If you are updating, make sure you have a backup of your StarUI Inventory.ini to keep your settings.&#xD;</description>
+						<files />
+						<typeDescriptor>
+							<type name="Required" />
+						</typeDescriptor>
+					</plugin>
+								
+				</plugins>
+			</group>
+		</optionalFileGroups>
+	</installStep>
+	</installSteps>
+	
+	<conditionalFileInstalls>
+		<patterns>
+			<pattern>
+				<dependencies operator="And">
+					<flagDependency flag="flag_vortex" value="Active" />
+					<flagDependency flag="flag_30fps" value="Active" />
+				</dependencies>
+				<files>
+					<folder source="Optional\30fps\Interface" destination="Data\Interface" />
+				</files>
+			</pattern>
+			<pattern>
+				<dependencies operator="And">
+					<flagDependency flag="flag_mo2" value="Active" />
+					<flagDependency flag="flag_30fps" value="Active" />
+				</dependencies>
+				<files>
+					<folder source="Optional\30fps\Interface" destination="Interface" />
+				</files>
+			</pattern>	
+			
+			<pattern>
+				<dependencies operator="And">
+					<flagDependency flag="flag_vortex" value="Active" />
+					<flagDependency flag="flag_120fps" value="Active" />
+				</dependencies>
+				<files>
+					<folder source="Optional\120fps\Interface" destination="Data\Interface" />
+				</files>
+			</pattern>
+			<pattern>
+				<dependencies operator="And">
+					<flagDependency flag="flag_mo2" value="Active" />
+					<flagDependency flag="flag_120fps" value="Active" />
+				</dependencies>
+				<files>
+					<folder source="Optional\120fps\Interface" destination="Interface" />
+				</files>
+			</pattern>
+		</patterns>
+	</conditionalFileInstalls>
+
+</config>

tests/data/fomod/moduleconfig/trade_barter.xml

@@ -0,0 +1,60 @@
+<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://qconsulting.ca/fo3/ModConfig5.0.xsd">
+<moduleName>Trade and Barter - Patches</moduleName>
+<moduleImage path="FOMOD\header.jpg"/>
+
+	<installSteps order="Explicit">	
+		<installStep name="Trade and Barter - Patches ESPLite">
+			<optionalFileGroups>
+				<group name="Core" type="SelectAny">
+					<plugins order="Explicit">
+						<plugin name="Beyond Bruma Patch">
+							<description>
+								ESPLite version
+							</description>
+							<files>
+								<folder source="01_bruma" destination="" priority="0"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="YASH Patch">
+							<description>
+								ESPLite version
+							</description>
+							<files>
+								<folder source="02_yash" destination="" priority="0"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="Keld-Nar Patch">
+							<description>
+								ESPLite version
+							</description>
+							<files>
+								<folder source="00_keld" destination="" priority="0"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+						<plugin name="Priest Vendors Patch">
+							<description>
+								ESPLite version
+							</description>
+							<files>
+								<folder source="03_vendor" destination="" priority="0"/>
+							</files>
+							<typeDescriptor>
+								<type name="Optional"/>
+							</typeDescriptor>
+						</plugin>
+					</plugins>
+				</group>
+			</optionalFileGroups>
+		</installStep>								
+		
+	</installSteps>
+</config>

tests/data/games/sse/Data/Skyrim.esm

@@ -0,0 +1 @@
+Skyrim.esm

tests/data/games/sse/Data/Update.esm

@@ -0,0 +1 @@
+Update.esm

tests/data/games/sse/SkyrimSE.exe

@@ -0,0 +1 @@
+SkyrimSE.exe

tests/data/games/sse/SkyrimSELauncher.exe

@@ -0,0 +1 @@
+SkyrimSELauncher.exe

tests/data/instance_complex.toml

@@ -0,0 +1,108 @@
+game = "sse"
+load_order = [
+    "Skyrim.esm",
+    "Update.esm",
+    "Dawnguard.esm",
+    "HearthFires.esm",
+    "Dragonborn.esm",
+    "ccBGSSSE001-Fish.esm",
+    "ccQDRSSE001-SurvivalMode.esl",
+    "ccBGSSSE037-Curios.esl",
+    "ccBGSSSE025-AdvDSGS.esm",
+    "_ResourcePack.esl",
+    "RaceMenu.esp",
+    "SkyUI_SE.esp",
+    "RaceMenuPlugin.esp",
+]
+game_file_overrides = [
+    "skse64_loader.exe -> SkyrimSELauncher.exe"
+]
+
+[[mods]]
+id = "skse"
+files = [
+    "Data/Scripts/math.pex",
+    "Data/Scripts/form.pex",
+    "Data/Scripts/soulgem.pex",
+    "Data/Scripts/formlist.pex",
+    "Data/Scripts/stringutil.pex",
+    "Data/Scripts/colorcomponent.pex",
+    "Data/Scripts/quest.pex",
+    "Data/Scripts/faction.pex",
+    "Data/Scripts/combatstyle.pex",
+    "Data/Scripts/actorbase.pex",
+    "Data/Scripts/potion.pex",
+    "Data/Scripts/actor.pex",
+    "Data/Scripts/game.pex",
+    "Data/Scripts/armor.pex",
+    "Data/Scripts/headpart.pex",
+    "Data/Scripts/objectreference.pex",
+    "Data/Scripts/weapon.pex",
+    "Data/Scripts/perk.pex",
+    "Data/Scripts/constructibleobject.pex",
+    "Data/Scripts/armoraddon.pex",
+    "Data/Scripts/textureset.pex",
+    "Data/Scripts/scroll.pex",
+    "Data/Scripts/actorvalueinfo.pex",
+    "Data/Scripts/equipslot.pex",
+    "Data/Scripts/art.pex",
+    "Data/Scripts/colorform.pex",
+    "Data/Scripts/weather.pex",
+    "Data/Scripts/gamedata.pex",
+    "Data/Scripts/skse.pex",
+    "Data/Scripts/sound.pex",
+    "Data/Scripts/formtype.pex",
+    "Data/Scripts/spawnertask.pex",
+    "Data/Scripts/netimmerse.pex",
+    "Data/Scripts/ingredient.pex",
+    "Data/Scripts/book.pex",
+    "Data/Scripts/ui.pex",
+    "Data/Scripts/leveleditem.pex",
+    "Data/Scripts/spell.pex",
+    "Data/Scripts/leveledspell.pex",
+    "Data/Scripts/modevent.pex",
+    "Data/Scripts/keyword.pex",
+    "Data/Scripts/activemagiceffect.pex",
+    "Data/Scripts/utility.pex",
+    "Data/Scripts/shout.pex",
+    "Data/Scripts/input.pex",
+    "Data/Scripts/race.pex",
+    "Data/Scripts/sounddescriptor.pex",
+    "Data/Scripts/wornobject.pex",
+    "Data/Scripts/ammo.pex",
+    "Data/Scripts/defaultobjectmanager.pex",
+    "Data/Scripts/camera.pex",
+    "Data/Scripts/apparatus.pex",
+    "skse64_1_6_1170.dll",
+    "Data/Scripts/magiceffect.pex",
+    "Data/Scripts/location.pex",
+    "Data/Scripts/alias.pex",
+    "Data/Scripts/treeobject.pex",
+    "Data/Scripts/leveledactor.pex",
+    "Data/Scripts/enchantment.pex",
+    "Data/Scripts/uicallback.pex",
+    "Data/Scripts/flora.pex",
+    "Data/Scripts/outfit.pex",
+    "Data/Scripts/cell.pex",
+]
+priority = 0
+
+[[mods]]
+id = "SkyUI-12604-35407"
+files = [
+    "SkyUI_SE.bsa -> Data/SkyUI_SE.bsa",
+    "SkyUI_SE.esp -> Data/SkyUI_SE.esp",
+]
+priority = 0
+
+[[mods]]
+id = "racemenu-19080-465102"
+files = [
+    "RaceMenu.esp -> Data/RaceMenu.esp",
+    "SKSE/Plugins/skee64.ini -> Data/SKSE/Plugins/skee64.ini",
+    "RaceMenu.bsa -> Data/RaceMenu.bsa",
+    "RaceMenuPlugin.esp -> Data/RaceMenuPlugin.esp",
+    "SKSE/Plugins/skee64.dll -> Data/SKSE/Plugins/skee64.dll",
+]
+priority = 0
+

tests/data/instance_minimal.toml

@@ -0,0 +1,2 @@
+game = "sse"
+

tests/data/mods/add_test_filter/image.jpg

@@ -0,0 +1 @@
+image.jpg

tests/data/mods/add_test_filter/plugin.esp

@@ -0,0 +1 @@
+plugin.esp

tests/data/mods/add_test_filter/readme.txt

@@ -0,0 +1 @@
+readme.txt

tests/data/mods/add_test_filter/sub/extra.esp

@@ -0,0 +1 @@
+extra.esp

tests/data/mods/add_test_nested/Data/plugin.esp

@@ -0,0 +1 @@
+plugin.esp-add_test_2

tests/data/mods/add_test_plain/plugin.esp

@@ -0,0 +1 @@
+plugin.esp-add_test_1

tests/data/mods/add_test_root/skse.exe

@@ -0,0 +1 @@
+skse.exe

tests/data/root_config_complex.toml

@@ -0,0 +1,47 @@
+mod_location = "mods"
+download_location = "downloads"
+nexus_api_key = "1234"
+
+[games.example_game]
+path = "/home/user/games/sse"
+kind = "sse"
+
+[games.sse]
+path = "games/sse"
+kind = "unkown"
+
+[instances.example1]
+path = "example1.toml"
+
+[instances.example2]
+path = "/home/user/example2.toml"
+
+[instances.instance_minimal]
+path = "instance_minimal.toml"
+
+[instances.instance_complex]
+path = "instance_complex.toml"
+
+[mods.mod1]
+path = "/home/user/mods/mod1"
+
+[mods."mod2"]
+path = "mod2"
+
+[mods.mod3]
+path = "mod3"
+
+[mods.add_test_plain]
+path = "add_test_plain"
+
+[mods.add_test_nested]
+path = "add_test_nested"
+
+[mods.add_test_root]
+path = "add_test_root"
+root_mod = true
+
+[mods.add_test_filter]
+path = "add_test_filter"
+ignore = [ "*.txt", "image.jpg", "sub/*" ]
+root_mod = true

tests/data/root_config_minimal.toml

@@ -0,0 +1 @@
+mod_location = "mods"

tests/fomod_test.rs

@@ -0,0 +1,42 @@
+use std::path::PathBuf;
+
+use fomod_manager::fomod::{self, FOModError};
+
+fn get_parent() -> PathBuf {
+    PathBuf::from(file!()).parent().unwrap().to_owned()
+}
+
+fn get_xml(filename: &str) -> PathBuf {
+    get_parent().join(format!("data/fomod/moduleconfig/{}", filename))
+}
+
+fn err_to_string(e: FOModError) -> String {
+    match e {
+        FOModError::Io(error) => format!("IO: {:?}", error),
+        FOModError::Parse(de_error) => match de_error {
+            quick_xml::DeError::UnexpectedStart(items) => {
+                format!("UnexpectedStart: {}", str::from_utf8(&items).unwrap())
+            }
+            _ => format!("Other: {:?}", de_error),
+        },
+    }
+}
+
+#[test]
+fn parse() {
+    for xml in [
+        "ineed.xml",
+        "trade_barter.xml",
+        "starui.xml",
+        "example_01.xml",
+        "example_02.xml",
+        "example_03.xml",
+        "example_04.xml",
+        "example_05.xml",
+        "banana.xml",
+        "po3tweaks.xml"
+    ] {
+        fomod::Config::load_from_file(get_xml(xml))
+            .unwrap_or_else(|e| panic!("Parse for {xml} with {}", err_to_string(e)));
+    }
+}

tests/game_test.rs

@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+use fomod_manager::types::RootConfig;
+
+fn get_parent() -> PathBuf {
+    PathBuf::from(file!()).parent().unwrap().to_owned()
+}
+
+fn load_root() -> RootConfig {
+    RootConfig::load_from_file(get_parent().join("data/root_config_complex.toml")).unwrap()
+}
+
+#[test]
+fn export_gamefiles() {
+    let root_config = load_root();
+
+    let game = root_config.game_by_id("sse").expect("No game found");
+
+    let links = game.export_links().expect("Failed to export game links");
+
+    assert!(
+        links.iter().all(|e| e.src().is_absolute()),
+        "Link src is not absolute"
+    );
+
+    assert_eq!(links.len(), 4, "Not all files linked");
+}

tests/modded_instance_test.rs

@@ -0,0 +1,53 @@
+use std::path::PathBuf;
+
+use fomod_manager::types::{Link, RootConfig};
+
+fn get_parent() -> PathBuf {
+    PathBuf::from(file!()).parent().unwrap().to_owned()
+}
+
+fn load_root() -> RootConfig {
+    RootConfig::load_from_file(get_parent().join("data/root_config_complex.toml")).unwrap()
+}
+
+#[test]
+fn parse_minimal() {
+    let root = load_root();
+
+    let inst = root.load_instance_by_id("instance_minimal");
+
+    assert!(inst.is_ok(), "Failed to load instance");
+
+    let unwraped = inst.expect("Asserted before");
+
+    assert_eq!(unwraped.game_id(), "sse");
+
+    assert!(unwraped.mods().is_empty());
+    assert!(unwraped.game_file_overrides().is_empty());
+    assert!(unwraped.load_order().is_empty());
+}
+
+#[test]
+fn parse_complex() {
+    let root = load_root();
+
+    let inst = root.load_instance_by_id("instance_complex");
+
+    assert!(inst.is_ok(), "Failed to load instance");
+
+    let unwraped = inst.expect("Asserted before");
+
+    assert_eq!(unwraped.game_id(), "sse");
+    assert_eq!(unwraped.load_order().len(), 13);
+    assert_eq!(
+        unwraped.game_file_overrides().first().unwrap(),
+        &Link::new("skse64_loader.exe", "SkyrimSELauncher.exe")
+    );
+
+    assert_eq!(unwraped.mods().len(), 3);
+    let test_mod = unwraped.mods().iter().find(|e| e.mod_id() == "SkyUI-12604-35407");
+    assert!(test_mod.is_some());
+
+    assert_eq!(test_mod.unwrap().priority(), 0);
+    assert_eq!(test_mod.unwrap().files().len(), 2);
+}

tests/root_config_test.rs

@@ -0,0 +1,70 @@
+use std::path::PathBuf;
+
+use fomod_manager::types::RootConfig;
+
+fn get_parent() -> PathBuf {
+    PathBuf::from(file!()).parent().unwrap().to_owned()
+}
+
+#[test]
+fn parse_minimal() {
+    let config =
+        RootConfig::load_from_file(get_parent().join("data/root_config_minimal.toml")).unwrap();
+
+    assert!(config.mod_location().ends_with("mods"));
+    assert!(
+        config.download_location().is_none(),
+        "Download location should be None"
+    );
+    assert!(config.nexus_api_key().is_none());
+}
+
+#[test]
+fn parse_complex() {
+    let config =
+        RootConfig::load_from_file(get_parent().join("data/root_config_complex.toml")).unwrap();
+
+    assert!(config.mod_location().ends_with("mods"));
+    assert!(
+        config
+            .download_location()
+            .is_some_and(|e| e.ends_with("downloads"))
+    );
+    assert_eq!(config.nexus_api_key(), Some("1234"));
+
+    assert!(
+        config
+            .game_by_id("example_game")
+            .is_some_and(|e| e.install_location() == "/home/user/games/sse"),
+        "Installed game wrong path"
+    );
+
+    assert!(
+        config
+            .game_by_id("sse")
+            .is_some_and(|e| e.install_location().is_absolute()),
+        "Relative game path was not resolved to absolute"
+    );
+
+    assert!(
+        config
+            .game_by_id("sse")
+            .is_some_and(|e| e.install_location().ends_with("games/sse")),
+        "Installed game wrong path"
+    );
+
+    assert!(config.game_by_id("starfield").is_none());
+
+    assert!(config.mod_by_id("mod1").is_some());
+    assert!(config.mod_by_id("mod100").is_none());
+    assert!(
+        config
+            .mod_by_id("mod1")
+            .is_some_and(|e| e.path() == "/home/user/mods/mod1")
+    );
+    assert!(
+        config
+            .mod_by_id("mod2")
+            .is_some_and(|e| e.path().ends_with("mod2"))
+    );
+}