Merge pull request 'multithreaded' (#6) from multithreaded into master

Reviewed-on: http://raspberrypi.fritz.box:7920/fx/modlist/pulls/6

5 files changed, 430 insertions, 246 deletions

diff --git a/src/commands/download.rs b/src/commands/download.rs
index ebfb4eb..a7cf744 100644
--- a/src/commands/download.rs
+++ b/src/commands/download.rs
@@ -1,26 +1,48 @@
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+
 use crate::{config::Cfg, List};
 use crate::{
     db::userlist_get_all_current_versions_with_mods,
     error::{ErrorType, MLError, MLE},
     files::{
-        clean_list_dir, delete_version, disable_version, download_versions, get_downloaded_versions,
+        clean_list_dir, delete_version, disable_version, download_versions,
+        get_downloaded_versions,
     },
     modrinth::get_raw_versions,
 };
+use crate::{PROGRESS_CHARS, STYLE_BAR_POS};
 
-pub async fn download(config: Cfg, liststack: Vec<List>, clean: bool, delete_old: bool) -> MLE<()> {
+pub async fn download(
+    config: &Cfg,
+    liststack: Vec<List>,
+    clean: bool,
+    delete_old: bool,
+) -> MLE<()> {
+    let mp = MultiProgress::new();
+    let download_p =
+        mp.add(ProgressBar::new(liststack.len().try_into().unwrap()));
+    download_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
 
     for current_list in liststack {
-        println!("Downloading current versions of mods in {}", current_list.id);
-        let downloaded_versions = get_downloaded_versions(current_list.clone())?;
-        // println!("To download: {:#?}", downloaded_versions);
-        let current_version_ids = match userlist_get_all_current_versions_with_mods(
-            config.clone(),
-            String::from(&current_list.id),
-        ) {
-            Ok(i) => Ok(i),
-            Err(e) => Err(MLError::new(ErrorType::DBError, e.to_string().as_str())),
-        }?;
+        download_p.set_message(format!("Download in {}", current_list.id));
+
+        let downloaded_versions =
+            get_downloaded_versions(current_list.clone())?;
+        let current_version_ids =
+            match userlist_get_all_current_versions_with_mods(
+                config,
+                String::from(&current_list.id),
+            ) {
+                Ok(i) => Ok(i),
+                Err(e) => Err(MLError::new(
+                    ErrorType::DBError,
+                    e.to_string().as_str(),
+                )),
+            }?;
 
         let mut to_download: Vec<String> = vec![];
         //(mod_id, version_id)
@@ -39,7 +61,10 @@ pub async fn download(config: Cfg, liststack: Vec<List>, clean: bool, delete_old
                     .ok_or("SOMETHING_HAS_REALLY_GONE_WRONG")
                     .unwrap();
                 if &current_version != downloaded_version {
-                    to_disable.push((mod_id.clone(), String::from(downloaded_version)));
+                    to_disable.push((
+                        mod_id.clone(),
+                        String::from(downloaded_version),
+                    ));
                     to_download.push(current_version);
                 }
             }
@@ -54,23 +79,57 @@ pub async fn download(config: Cfg, liststack: Vec<List>, clean: bool, delete_old
                 current_list.clone(),
                 config.clone(),
                 get_raw_versions(&config.apis.modrinth, to_download).await,
+                &mp,
+                &download_p,
             )
             .await?;
         } else {
-            println!("There are no new versions to download");
+            download_p.println(format!(
+                "There are no new versions to download for {}",
+                current_list.id
+            ));
         }
 
         if !to_disable.is_empty() {
+            let d_p = mp.insert_before(
+                &download_p,
+                ProgressBar::new(to_disable.len().try_into().unwrap()),
+            );
+            d_p.set_style(
+                ProgressStyle::with_template(STYLE_BAR_POS)
+                    .unwrap()
+                    .progress_chars(PROGRESS_CHARS),
+            );
             for ver in to_disable {
                 if delete_old {
-                    println!("Deleting version {} for mod {}", ver.1, ver.0);
-                    delete_version(current_list.clone(), ver.1)?;
+                    d_p.set_message(format!("Delete version {}", ver.1));
+                    d_p.inc(1);
+                    delete_version(&current_list, ver.1)?;
                 } else {
-                    disable_version(config.clone(), current_list.clone(), ver.1, ver.0)?;
+                    d_p.set_message(format!("Disable version {}", ver.1));
+                    d_p.inc(1);
+                    disable_version(
+                        config,
+                        current_list.clone(),
+                        ver.1,
+                        ver.0,
+                    )?;
                 };
             }
+
+            let del_msg = if delete_old {
+                "Deleted all old versions"
+            } else {
+                "Disabled all old versions"
+            };
+
+            d_p.finish_with_message(del_msg);
         }
+
+        download_p.inc(1);
     }
 
+    download_p.finish_with_message("Downloaded all lists");
+
     Ok(())
 }
diff --git a/src/commands/io.rs b/src/commands/io.rs
index dd294bc..8e44b2b 100644
--- a/src/commands/io.rs
+++ b/src/commands/io.rs
@@ -1,12 +1,16 @@
+use indicatif::{ProgressBar, ProgressStyle};
 use serde::{Deserialize, Serialize};
 use std::fs::File;
 use std::io::prelude::*;
 
 use crate::{
     config::Cfg,
-    db::{lists_get, lists_get_all_ids, lists_insert, userlist_get_set_version, userlist_get_all_ids, userlist_get_current_version},
+    db::{
+        lists_get, lists_get_all_ids, lists_insert, userlist_get_all_ids,
+        userlist_get_current_version, userlist_get_set_version,
+    },
     error::MLE,
-    mod_add, IDSelector, List, Modloader, AddMod,
+    mod_add, AddMod, IDSelector, List, Modloader, STYLE_OPERATION,
 };
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -17,14 +21,14 @@ struct Export {
 #[derive(Debug, Serialize, Deserialize)]
 struct ExportVersion {
     version: String,
-    set: bool
+    set: bool,
 }
 
 impl ExportVersion {
-    fn from(config: Cfg, list_id: &str, mod_id: &str) -> MLE<Self> {
+    fn from(config: &Cfg, list_id: &str, mod_id: &str) -> MLE<Self> {
         Ok(Self {
-            version: userlist_get_current_version(config.clone(), list_id, mod_id)?,
-            set: userlist_get_set_version(config.clone(), list_id, mod_id)?
+            version: userlist_get_current_version(config, list_id, mod_id)?,
+            set: userlist_get_set_version(config, list_id, mod_id)?,
         })
     }
 }
@@ -39,18 +43,18 @@ struct ExportList {
 }
 
 impl ExportList {
-    pub fn from(config: Cfg, list_id: String, download: bool) -> MLE<Self> {
-        let list = lists_get(config.clone(), String::from(&list_id))?;
+    pub fn from(config: &Cfg, list_id: &str, download: bool) -> MLE<Self> {
+        let list = lists_get(config, list_id)?;
 
         let mut dl_folder = None;
         if download {
             dl_folder = Some(list.download_folder)
         };
 
-        let mods = userlist_get_all_ids(config.clone(), &list_id)?;
+        let mods = userlist_get_all_ids(config, list_id)?;
         let mut versions = vec![];
         for m in mods {
-            versions.push(ExportVersion::from(config.clone(), &list_id, &m)?)
+            versions.push(ExportVersion::from(config, list_id, &m)?)
         }
 
         Ok(Self {
@@ -63,29 +67,46 @@ impl ExportList {
     }
 }
 
-pub fn export(config: Cfg, list: Option<String>) -> MLE<()> {
+pub fn export(config: &Cfg, list: Option<String>) -> MLE<()> {
+    let progress = ProgressBar::new_spinner();
+    progress.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+
     let mut list_ids: Vec<String> = vec![];
     if list.is_none() {
-        list_ids = lists_get_all_ids(config.clone())?;
+        list_ids = lists_get_all_ids(config)?;
     } else {
-        list_ids.push(lists_get(config.clone(), list.unwrap())?.id);
+        list_ids.push(lists_get(config, &list.unwrap())?.id);
     }
+
     let mut lists: Vec<ExportList> = vec![];
     for list_id in list_ids {
-        lists.push(ExportList::from(config.clone(), list_id, true)?);
+        progress.set_message(format!("Export {}", list_id));
+        //TODO download option/ new download on import
+        lists.push(ExportList::from(config, &list_id, true)?);
     }
 
     let toml = toml::to_string(&Export { lists })?;
 
-    let filestr = dirs::home_dir().unwrap().join("mlexport.toml");
+    let filestr = dirs::home_dir()
+        .unwrap()
+        .join("mlexport.toml")
+        .into_os_string()
+        .into_string()
+        .unwrap();
 
-    let mut file = File::create(filestr.into_os_string().into_string().unwrap().as_str())?;
+    progress.set_message("Create file");
+    let mut file = File::create(&filestr)?;
     file.write_all(toml.as_bytes())?;
+    progress.finish_with_message(format!("Exported to {}", filestr));
 
     Ok(())
 }
 
-pub async fn import(config: Cfg, file_str: String, direct_download: bool) -> MLE<()> {
+pub async fn import(
+    config: &Cfg,
+    file_str: &str,
+    direct_download: bool,
+) -> MLE<()> {
     let mut file = File::open(file_str)?;
     let mut content = String::new();
     file.read_to_string(&mut content)?;
@@ -99,18 +120,21 @@ pub async fn import(config: Cfg, file_str: String, direct_download: bool) -> MLE
             download_folder: exportlist.download_folder.ok_or("NO_DL").unwrap(),
         };
         lists_insert(
-            config.clone(),
-            list.id.clone(),
-            list.mc_version.clone(),
-            list.modloader.clone(),
-            String::from(&list.download_folder),
+            config,
+            &list.id,
+            &list.mc_version,
+            &list.modloader,
+            &list.download_folder,
         )?;
 
         let mut ver_ids = vec![];
         for id in exportlist.versions {
-            ver_ids.push(AddMod { id: IDSelector::VersionID(id.version), set_version: id.set} );
+            ver_ids.push(AddMod {
+                id: IDSelector::VersionID(id.version),
+                set_version: id.set,
+            });
         }
-        mod_add(config.clone(), ver_ids, list, direct_download).await?;
+        mod_add(config, ver_ids, list, direct_download).await?;
     }
     Ok(())
 }
diff --git a/src/commands/list.rs b/src/commands/list.rs
index 4aa4306..3665446 100644
--- a/src/commands/list.rs
+++ b/src/commands/list.rs
@@ -1,11 +1,13 @@
+use indicatif::{ProgressBar, ProgressStyle};
+
 use crate::{
     config::Cfg,
     db::{
-        config_change_current_list, config_get_current_list, lists_get, lists_insert, lists_remove,
-        lists_version, lists_get_all_ids,
+        config_change_current_list, config_get_current_list, lists_get,
+        lists_get_all_ids, lists_insert, lists_remove, lists_version,
     },
-    error::{MLE, MLError, ErrorType},
-    update, Modloader,
+    error::{ErrorType, MLError, MLE},
+    update, Modloader, STYLE_OPERATION,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -16,31 +18,47 @@ pub struct List {
     pub download_folder: String,
 }
 
-pub fn get_current_list(config: Cfg) -> MLE<List> {
-    let id = config_get_current_list(config.clone())?;
-    lists_get(config, id)
+pub fn get_current_list(config: &Cfg) -> MLE<List> {
+    let id = config_get_current_list(config)?;
+    lists_get(config, &id)
 }
 
 pub fn list_add(
-    config: Cfg,
-    id: String,
-    mc_version: String,
-    modloader: Modloader,
-    directory: String,
+    config: &Cfg,
+    id: &str,
+    mc_version: &str,
+    modloader: &Modloader,
+    directory: &str,
 ) -> MLE<()> {
-    lists_insert(config, id, mc_version, modloader, directory)
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!("Create {}", id));
+    lists_insert(config, id, mc_version, modloader, directory)?;
+    p.finish_with_message(format!("Created {}", id));
+    Ok(())
 }
 
-pub fn list_change(config: Cfg, id: String) -> MLE<()> {
-    if lists_get_all_ids(config.clone())?.into_iter().find(|l| l == &id).is_none() {
+pub fn list_change(config: &Cfg, id: &str) -> MLE<()> {
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!("Change default list to {}", id));
+
+    if !lists_get_all_ids(config)?.into_iter().any(|l| l == id) {
         return Err(MLError::new(ErrorType::ArgumentError, "List not found"));
     };
-    println!("Change default list to: {}", id);
-    config_change_current_list(config, id)
+    config_change_current_list(config, id)?;
+
+    p.finish_with_message(format!("Changed default list to {}", id));
+    Ok(())
 }
 
-pub fn list_remove(config: Cfg, id: String) -> MLE<()> {
-    lists_remove(config, id)
+pub fn list_remove(config: &Cfg, id: &str) -> MLE<()> {
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!("Remove {}", id));
+    lists_remove(config, id)?;
+    p.finish_with_message(format!("Removed {}", id));
+    Ok(())
 }
 
 ///Changing the current lists version and updating it
@@ -50,31 +68,34 @@ pub fn list_remove(config: Cfg, id: String) -> MLE<()> {
 /// * `config` - The current config
 /// * `args` - All args, to extract the new version
 pub async fn list_version(
-    config: Cfg,
-    id: String,
+    config: &Cfg,
+    id: &str,
     mc_version: String,
     download: bool,
     delete: bool,
 ) -> MLE<()> {
-    println!(
+    let p = ProgressBar::new_spinner();
+    p.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+    p.set_message(format!(
         "Change version for list {} to minecraft version: {}",
         id, mc_version
-    );
+    ));
 
-    lists_version(config.clone(), &id, &mc_version)?;
+    lists_version(config, id, &mc_version)?;
+
+    p.finish_with_message(format!(
+        "Changed version for list {} to minecraft version: {}",
+        id, mc_version
+    ));
 
-    println!(
-        "\nCheck for updates for new minecraft version in list {}",
-        id
-    );
-    let list = lists_get(config.clone(), id)?;
+    let list = lists_get(config, id)?;
     update(config, vec![list], true, download, delete).await
 }
 
-pub fn list_list(config: Cfg) -> MLE<()> {
-    let lists = lists_get_all_ids(config.clone())?;
+pub fn list_list(config: &Cfg) -> MLE<()> {
+    let lists = lists_get_all_ids(config)?;
     for list in lists {
-        let l = lists_get(config.clone(), list)?;
+        let l = lists_get(config, &list)?;
         println!("{}: | {} | {}", l.id, l.mc_version, l.modloader)
     }
     Ok(())
diff --git a/src/commands/modification.rs b/src/commands/modification.rs
index 9a1a651..4488b70 100644
--- a/src/commands/modification.rs
+++ b/src/commands/modification.rs
@@ -1,24 +1,30 @@
-use std::{io::Write, collections::HashMap};
+use std::collections::HashMap;
+
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 
 use crate::{
     config::Cfg,
     db::{
-        lists_get_all_ids, mods_get_id, mods_insert, mods_remove, userlist_get_all_ids,
-        userlist_get_current_version, userlist_insert, userlist_remove, mods_get_info,
+        lists_get_all_ids, mods_get_id, mods_get_info, mods_insert,
+        mods_remove, userlist_get_all_ids, userlist_get_current_version,
+        userlist_insert, userlist_remove,
     },
     error::{ErrorType, MLError, MLE},
     files::{delete_version, download_versions},
-    modrinth::{extract_current_version, get_raw_versions, project, projects, versions, Version},
-    List,
+    modrinth::{
+        extract_current_version, get_raw_versions, project, projects, versions,
+        Version,
+    },
+    List, PROGRESS_CHARS, STYLE_BAR_POS, STYLE_OPERATION,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct AddMod {
     pub id: IDSelector,
-    pub set_version: bool
+    pub set_version: bool,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum IDSelector {
     ModificationID(String),
     VersionID(String),
@@ -36,54 +42,76 @@ pub struct ProjectInfo {
 }
 
 pub async fn mod_add(
-    config: Cfg,
+    config: &Cfg,
     mods: Vec<AddMod>,
     list: List,
     direct_download: bool,
 ) -> MLE<()> {
-    println!("Add mods to {}", list.id);
-    println!("  └Add mods:");
+    let mp = MultiProgress::new();
 
     let mut mod_ids: Vec<(String, bool)> = Vec::new();
     let mut ver_ids: Vec<(String, bool)> = Vec::new();
 
+    let add_p = mp.add(ProgressBar::new(mods.len().try_into().unwrap()));
+    add_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
+    add_p.set_message("Sort ids");
+
     //"Sort" project ids from version ids to be able to handle them differently but in a batch
     for m in mods {
+        add_p.inc(1);
         match m.id {
-            IDSelector::ModificationID(pid) => mod_ids.push((pid, m.set_version)),
+            IDSelector::ModificationID(pid) => {
+                mod_ids.push((pid, m.set_version))
+            }
             IDSelector::VersionID(vid) => ver_ids.push((vid, m.set_version)),
         }
     }
 
+    add_p.set_message("Get infos");
+
     let mut projectinfo: Vec<ProjectInfo> = Vec::new();
     if !mod_ids.is_empty() {
-        projectinfo.append(&mut get_mod_infos(config.clone(), mod_ids, list.clone()).await?)
+        projectinfo
+            .append(&mut get_mod_infos(config, mod_ids, list.clone()).await?);
     };
     if !ver_ids.is_empty() {
-        projectinfo.append(&mut get_ver_info(config.clone(), ver_ids).await?)
+        projectinfo.append(&mut get_ver_info(config, ver_ids).await?);
     };
 
     if projectinfo.is_empty() {
         return Err(MLError::new(ErrorType::ArgumentError, "NO_IDS?"));
     };
 
+    add_p.set_message("Add mods to database");
+
     let mut downloadstack: Vec<Version> = Vec::new();
 
     //Adding each mod to the lists and downloadstack
-    if projectinfo.len() == 1 {
-        println!("  └Insert mod in list {} and save infos", list.id);
-    } else {
-        println!("  └Insert mods in list {} and save infos", list.id);
-    }
+    let project_p = mp.insert_before(
+        &add_p,
+        ProgressBar::new(projectinfo.len().try_into().unwrap()),
+    );
+    project_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
 
     for project in projectinfo {
+        project_p.set_message(format!("Add {}", project.title));
+
         let current_version_id = if project.current_version.is_none() {
             String::from("NONE")
         } else {
             project.current_version.clone().unwrap().id
         };
+
         match userlist_insert(
-            config.clone(),
+            config,
             &list.id,
             &project.mod_id,
             &current_version_id,
@@ -92,7 +120,10 @@ pub async fn mod_add(
             project.set_version,
         ) {
             Err(e) => {
-                let expected_err = format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
+                let expected_err = format!(
+                    "SQL: UNIQUE constraint failed: {}.mod_id",
+                    list.id
+                );
                 if e.to_string() == expected_err {
                     Err(MLError::new(
                         ErrorType::ModError,
@@ -106,7 +137,7 @@ pub async fn mod_add(
         }?;
 
         match mods_insert(
-            config.clone(),
+            config,
             &project.mod_id,
             &project.slug,
             &project.title,
@@ -124,18 +155,35 @@ pub async fn mod_add(
         if project.current_version.is_some() {
             downloadstack.push(project.current_version.unwrap())
         };
+
+        project_p.inc(1);
     }
 
+    project_p.finish_with_message("Added all mods to the database");
+
     //Download all the added mods
     if direct_download {
-        download_versions(list.clone(), config.clone(), downloadstack).await?;
+        add_p.set_message("Download mods");
+        download_versions(
+            list.clone(),
+            config.clone(),
+            downloadstack,
+            &mp,
+            &add_p,
+        )
+        .await?;
     };
 
+    add_p.finish_with_message("Added all mods");
+
     Ok(())
 }
 
-async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) -> MLE<Vec<ProjectInfo>> {
-
+async fn get_mod_infos(
+    config: &Cfg,
+    mod_ids: Vec<(String, bool)>,
+    list: List,
+) -> MLE<Vec<ProjectInfo>> {
     let mut setmap: HashMap<String, bool> = HashMap::new();
 
     let mut ids = vec![];
@@ -154,8 +202,6 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
         _ => panic!("PANIC"),
     };
     for project in m_projects {
-        println!("\t└{}", project.title);
-        println!("\t  └Get versions");
         let available_versions = versions(
             &config.apis.modrinth,
             String::from(&project.id),
@@ -167,8 +213,8 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
         let current_version: Option<Version>;
         let file: String;
         if !available_versions.is_empty() {
-            let current_id = extract_current_version(available_versions.clone())?;
-            println!("\t  └Current version: {}", current_id);
+            let current_id =
+                extract_current_version(available_versions.clone())?;
 
             current_version = Some(
                 available_versions
@@ -177,19 +223,15 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
                     .find(|v| v.id == current_id)
                     .unwrap(),
             );
-            
+
             // match primary, if none?
-            let files = current_version
-                .clone()
-                .ok_or("")
-                .unwrap()
-                .files;
+            let files = current_version.clone().ok_or("").unwrap().files;
 
             file = match files.clone().into_iter().find(|f| f.primary) {
-                    Some(f) => f,
-                    None => { files[0].clone() }
-                }
-                .url;
+                Some(f) => f,
+                None => files[0].clone(),
+            }
+            .url;
 
             for ver in available_versions {
                 available_versions_vec.push(ver.id);
@@ -197,15 +239,14 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
 
             projectinfo.push(ProjectInfo {
                 mod_id: String::from(&project.id),
-                slug: project.slug,
+                slug: project.slug.clone(),
                 title: project.title,
                 current_version,
                 applicable_versions: available_versions_vec,
                 download_link: file,
-                set_version: setmap.get(&project.id).unwrap().clone(),
+                set_version: *setmap.get(&project.slug).unwrap(),
             })
         } else {
-            println!("\t  └There's currently no mod version for your specified target");
             current_version = None;
             file = String::from("NONE");
             available_versions_vec.push(String::from("NONE"));
@@ -216,7 +257,7 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
                 current_version,
                 applicable_versions: available_versions_vec,
                 download_link: file,
-                set_version: setmap.get(&project.id).unwrap().clone(),
+                set_version: *setmap.get(&project.id).unwrap(),
             })
         }
     }
@@ -224,8 +265,10 @@ async fn get_mod_infos(config: Cfg, mod_ids: Vec<(String, bool)>, list: List) ->
     Ok(projectinfo)
 }
 
-async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<ProjectInfo>> {
-
+async fn get_ver_info(
+    config: &Cfg,
+    ver_ids: Vec<(String, bool)>,
+) -> MLE<Vec<ProjectInfo>> {
     let mut setmap: HashMap<String, bool> = HashMap::new();
 
     let mut ids = vec![];
@@ -248,14 +291,15 @@ async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<Proj
 
     for (i, project) in v_projects.into_iter().enumerate() {
         let version = &v_versions[i];
-        println!("\t└{}({})", project.title, version.id);
-        let file = version
-            .clone()
-            .files
-            .into_iter()
-            .find(|f| f.primary)
-            .unwrap()
-            .url;
+
+        let files = version.clone().files;
+
+        let file = match files.clone().into_iter().find(|f| f.primary) {
+            Some(f) => f,
+            None => files[0].clone(),
+        }
+        .url;
+
         projectinfo.push(ProjectInfo {
             mod_id: String::from(&project.id),
             slug: project.slug,
@@ -263,7 +307,7 @@ async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<Proj
             current_version: Some(version.clone()),
             applicable_versions: vec![String::from(&version.id)],
             download_link: file,
-            set_version: setmap.get(&version.id).unwrap().clone(),
+            set_version: *setmap.get(&version.id).unwrap(),
         })
     }
     Ok(projectinfo)
@@ -275,48 +319,45 @@ async fn get_ver_info(config: Cfg, ver_ids: Vec<(String, bool)>) -> MLE<Vec<Proj
 /// * `config` - config struct
 /// * `id` - name, slug or id of the mod
 /// * `list` - List struct
-pub fn mod_remove(config: Cfg, id: &str, list: List) -> MLE<()> {
+pub fn mod_remove(config: &Cfg, id: &str, list: &List) -> MLE<()> {
+    let progress = ProgressBar::new_spinner();
+    progress.set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+
     let mod_id = mods_get_id(&config.data, id)?;
 
-    println!("Remove mod {} from {}", mods_get_info(config.clone(), &mod_id)?.title, list.id);
-    let version = userlist_get_current_version(config.clone(), &list.id, &mod_id)?;
+    let info = mods_get_info(config, &mod_id)?;
 
-    print!("  └Remove from list");
-    //Force flush of stdout, else print! doesn't print instantly
-    std::io::stdout().flush()?;
-    userlist_remove(config.clone(), &list.id, &mod_id)?;
-    println!(" ✓");
+    progress.set_message(format!("Remove {} from {}", info.title, list.id));
 
-    print!("  └Delete file");
-    //Force flush of stdout, else print! doesn't print instantly
-    std::io::stdout().flush()?;
+    let version = userlist_get_current_version(config, &list.id, &mod_id)?;
+
+    userlist_remove(config, &list.id, &mod_id)?;
+
+    progress.set_message("Delete file");
     match delete_version(list, version) {
         Ok(_) => (),
         Err(err) => {
-            if err.to_string() !=  "User input not accepted: VERSION_NOT_FOUND_IN_FILES" {
+            if err.to_string()
+                != "User input not accepted: VERSION_NOT_FOUND_IN_FILES"
+            {
                 return Err(err);
             };
-            ()
-        },
+        }
     };
-    println!(" ✓");
 
-    print!("  └Clean main db table");
-    //Force flush of stdout, else print! doesn't print instantly
-    std::io::stdout().flush()?;
-    let list_ids = lists_get_all_ids(config.clone())?;
+    progress.set_message("Check main list");
+    let list_ids = lists_get_all_ids(config)?;
 
     // Remove mod from main list if not used elsewhere
     let mut mod_used = false;
     for id in list_ids {
-        let mods = match userlist_get_all_ids(config.clone(), &id) {
+        let mods = match userlist_get_all_ids(config, &id) {
             Ok(m) => m,
             Err(err) => {
-                if err.to_string() ==  "Database: NO_MODS_USERLIST" {
-                    println!(" ✓");
+                if err.to_string() == "Database: NO_MODS_USERLIST" {
                     return Ok(());
                 };
-                return Err(err)
+                return Err(err);
             }
         };
         if mods.contains(&mod_id) {
@@ -326,9 +367,14 @@ pub fn mod_remove(config: Cfg, id: &str, list: List) -> MLE<()> {
     }
 
     if !mod_used {
-        mods_remove(config, mod_id)?;
+        progress.set_message("Remove from main list");
+        mods_remove(config, &mod_id)?;
     };
-    println!(" ✓");
+
+    progress.finish_with_message(format!(
+        "Removed {} from {}",
+        info.title, list.id
+    ));
 
     Ok(())
 }
diff --git a/src/commands/update.rs b/src/commands/update.rs
index d3a282b..c19c02c 100644
--- a/src/commands/update.rs
+++ b/src/commands/update.rs
@@ -1,49 +1,81 @@
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+
 use crate::{
     config::Cfg,
     db::{
         mods_get_info, userlist_change_versions, userlist_get_all_ids,
-        userlist_get_applicable_versions, userlist_get_current_version, userlist_get_set_version,
+        userlist_get_applicable_versions, userlist_get_current_version,
+        userlist_get_set_version,
     },
     error::{ErrorType, MLError, MLE},
-    files::{clean_list_dir, delete_version, disable_version, download_versions},
+    files::{
+        clean_list_dir, delete_version, disable_version, download_versions,
+    },
     modrinth::{extract_current_version, versions, Version},
-    List,
+    List, PROGRESS_CHARS, STYLE_BAR_POS, STYLE_OPERATION,
 };
 
 pub async fn update(
-    config: Cfg,
+    config: &Cfg,
     liststack: Vec<List>,
     clean: bool,
     direct_download: bool,
     delete_old: bool,
 ) -> MLE<()> {
+    let mp = MultiProgress::new();
+
+    let update_p =
+        mp.add(ProgressBar::new(liststack.len().try_into().unwrap()));
+    update_p.set_style(
+        ProgressStyle::with_template(STYLE_BAR_POS)
+            .unwrap()
+            .progress_chars(PROGRESS_CHARS),
+    );
+
     for current_list in liststack {
-        println!("Update mods in {}", current_list.id);
-        let mods = userlist_get_all_ids(config.clone(), &current_list.id)?;
+        update_p.set_message(format!("Update {}", current_list.id));
 
-        let mut current_versions: Vec<(String, String)> = vec![];
+        let list_p = mp.insert_before(&update_p, ProgressBar::new(2));
+        list_p
+            .set_style(ProgressStyle::with_template(STYLE_OPERATION).unwrap());
+        list_p.set_message("Update mods");
+
+        let mods = userlist_get_all_ids(config, &current_list.id)?;
+
+        let list_u_p = mp.insert_before(
+            &list_p,
+            ProgressBar::new(mods.len().try_into().unwrap()),
+        );
+        list_u_p.set_style(
+            ProgressStyle::with_template(STYLE_BAR_POS)
+                .unwrap()
+                .progress_chars(PROGRESS_CHARS),
+        );
 
+        let mut current_versions: Vec<(String, String)> = vec![];
         let mut updatestack: Vec<Version> = vec![];
 
         for id in mods {
-            let info = mods_get_info(config.clone(), &id)?;
-            println!("  ├{}", info.title);
+            let info = mods_get_info(config, &id)?;
+            list_u_p.set_message(format!("Update {}", info.title));
 
-            if userlist_get_set_version(config.clone(), &current_list.id, &id)? {
-                println!("  │ └Set version, skipping update");
+            //Skip check if version is set
+            if userlist_get_set_version(config, &current_list.id, &id)? {
+                list_u_p.inc(1);
                 continue;
             }
 
             //Getting current installed version for disable or delete
             let disable_version =
-                userlist_get_current_version(config.clone(), &current_list.id, &id)?;
+                userlist_get_current_version(config, &current_list.id, &id)?;
 
             updatestack.push(
                 match specific_update(
-                    config.clone(),
+                    config,
                     clean,
                     current_list.clone(),
-                    String::from(&id),
+                    &id,
+                    &list_u_p,
                 )
                 .await
                 {
@@ -53,46 +85,94 @@ pub async fn update(
                     }
                     Err(e) => {
                         if e.to_string() == "Mod: NO_UPDATE_AVAILABLE" {
-                            println!(
-                                "  │ └No new version found for the specified minecraft version"
-                            );
                         } else {
                             return Err(e);
                         };
+                        list_u_p.inc(1);
                         continue;
                     }
                 },
-            )
+            );
+            list_u_p.inc(1);
         }
 
+        list_u_p.finish_with_message(format!(
+            "Updated mods in {}",
+            current_list.id
+        ));
+
         if clean {
+            list_p.set_message("Cleaning");
             clean_list_dir(&current_list)?;
         };
 
         if direct_download && !updatestack.is_empty() {
-            download_versions(current_list.clone(), config.clone(), updatestack).await?;
+            download_versions(
+                current_list.clone(),
+                config.clone(),
+                updatestack,
+                &mp,
+                &list_p,
+            )
+            .await?;
 
             //Disable old versions
             if !clean {
+                let d_p = mp.insert_before(
+                    &list_p,
+                    ProgressBar::new(
+                        current_versions.len().try_into().unwrap(),
+                    ),
+                );
+                d_p.set_style(
+                    ProgressStyle::with_template(STYLE_BAR_POS)
+                        .unwrap()
+                        .progress_chars(PROGRESS_CHARS),
+                );
                 for ver in current_versions {
                     if delete_old {
-                        println!("    └Delete version {}", ver.0);
-                        delete_version(current_list.clone(), ver.0)?;
+                        d_p.set_message(format!("Delete version {}", ver.0));
+                        d_p.inc(1);
+                        delete_version(&current_list, ver.0)?;
                     } else if ver.0 != "NONE" {
-                        println!("    └Disable version {}", ver.0);
-                        disable_version(config.clone(), current_list.clone(), ver.0, ver.1)?;
+                        d_p.set_message(format!("Disable version {}", ver.0));
+                        d_p.inc(1);
+                        disable_version(
+                            config,
+                            current_list.clone(),
+                            ver.0,
+                            ver.1,
+                        )?;
                     };
                 }
+
+                let del_msg = if delete_old {
+                    "Deleted all old versions"
+                } else {
+                    "Disabled all old versions"
+                };
+
+                d_p.finish_with_message(del_msg);
             }
         };
+        list_p.finish_with_message(format!("Updated {}", current_list.id));
+        update_p.inc(1);
     }
 
+    update_p.finish_with_message("Updated all lists");
+
     Ok(())
 }
 
-async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> MLE<Version> {
+async fn specific_update(
+    config: &Cfg,
+    clean: bool,
+    list: List,
+    id: &str,
+    progress: &ProgressBar,
+) -> MLE<Version> {
     let applicable_versions =
-        versions(&config.apis.modrinth, String::from(&id), list.clone()).await;
+        versions(&config.apis.modrinth, String::from(id), list.clone()).await;
 
     let mut versions: Vec<String> = vec![];
 
@@ -108,19 +188,19 @@ async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> ML
     if clean
         || (versions.join("|")
             != userlist_get_applicable_versions(
-                config.clone(),
+                config,
                 String::from(&list.id),
-                String::from(&id),
+                String::from(id),
             )?)
     {
         let current_str = extract_current_version(applicable_versions.clone())?;
 
-        if clean {
-            println!("\t  └Add version to downloadstack");
-        } else {
-            println!("\t  └Get versions for specified minecraft versions");
-            println!("\t  └New current version: {}", current_str);
-        };
+        if !clean {
+            progress.println(format!(
+                "Found new version for {}",
+                mods_get_info(config, id).unwrap().title
+            ));
+        }
 
         //get new versions
         let current_ver = match applicable_versions
@@ -133,73 +213,27 @@ async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> ML
         }?;
         current.push(current_ver.clone());
 
-        let link = match current_ver
-            .files
-            .into_iter()
-            .find(|f| f.primary)
-            .ok_or("!no primary in links")
-        {
-            Ok(p) => Ok(p),
-            Err(e) => Err(MLError::new(ErrorType::Other, e)),
-        }?
+        let files = &current_ver.files;
+
+        let link = match files.clone().into_iter().find(|f| f.primary) {
+            Some(f) => f,
+            None => files[0].clone(),
+        }
         .url;
-        userlist_change_versions(config, list.id, current_str, versions.join("|"), link, id)?;
+
+        userlist_change_versions(
+            config,
+            list.id,
+            current_str,
+            versions.join("|"),
+            link,
+            id.to_string(),
+        )?;
     }
 
     if current.is_empty() {
         return Err(MLError::new(ErrorType::ModError, "NO_UPDATE_AVAILABLE"));
     };
 
-    //println!(" └✔️");
     Ok(current[0].clone())
 }
-
-// #[tokio::test]
-// async fn download_updates_test() {
-//     use crate::{
-//         modrinth::{Hash, Version, VersionFile, VersionType},
-//         List, Modloader,
-//     };
-//
-//     let config = Cfg::init().unwrap();
-//     let current_list = List {
-//         id: String::from("..."),
-//         mc_version: String::from("..."),
-//         modloader: Modloader::Fabric,
-//         download_folder: String::from("./dev/tests/dl"),
-//     };
-//
-//     let versions = vec![Version {
-//             id: "dEqtGnT9".to_string(),
-//             project_id: "kYuIpRLv".to_string(),
-//             author_id: "Qnt13hO8".to_string(),
-//             featured: true,
-//             name: "1.2.2-1.19 - Fabric".to_string(),
-//             version_number: "1.2.2-1.19".to_string(),
-//             changelog: None,
-//             date_published: "2022-11-02T17:41:43.072267Z".to_string(),
-//             downloads: 58,
-//             version_type: VersionType::release,
-//             files: vec![VersionFile {
-//                     hashes: Hash {
-//                         sha1: "fdc6dc39427fc92cc1d7ad8b275b5b83325e712b".to_string(),
-//                         sha512: "5b372f00d6e5d6a5ef225c3897826b9f6a2be5506905f7f71b9e939779765b41be6f2a9b029cfc752ad0751d0d2d5f8bb4544408df1363eebdde15641e99a849".to_string()
-//                     },
-//                     url: "https://cdn.modrinth.com/data/kYuIpRLv/versions/dEqtGnT9/waveycapes-fabric-1.2.2-mc1.19.2.jar".to_string(),
-//                     filename: "waveycapes-fabric-1.2.2-mc1.19.2.jar".to_string(),
-//                     primary: true,
-//                     size: 323176
-//             }],
-//             game_versions: vec![
-//                 "1.19".to_string(),
-//                 "1.19.1".to_string(),
-//                 "1.19.2".to_string()
-//             ],
-//             loaders: vec![
-//                 "fabric".to_string()
-//             ]
-//         }];
-//     assert!(download_versions(current_list, config, versions)
-//         .await
-//         .is_ok())
-// }