4 files changed, 177 insertions, 48 deletions

diff --git a/src/commands/download.rs b/src/commands/download.rs
index 7748d15..2714630 100644
--- a/src/commands/download.rs
+++ b/src/commands/download.rs
@@ -47,7 +47,7 @@ pub async fn download(config: Cfg, input: Input) -> MLE<()> {
         if input.clean { clean_list_dir(&current_list)? };
 
         if !to_download.is_empty() {
-            download_versions(current_list.clone(), config.clone(), get_raw_versions(String::from(&config.apis.modrinth), to_download).await).await?;
+            download_versions(current_list.clone(), config.clone(), get_raw_versions(&config.apis.modrinth, to_download).await).await?;
         } else {
             println!("There are no new versions to download");
         }
diff --git a/src/commands/io.rs b/src/commands/io.rs
index 44604d1..a3d056f 100644
--- a/src/commands/io.rs
+++ b/src/commands/io.rs
@@ -2,7 +2,7 @@ use std::fs::File;
 use std::io::prelude::*;
 use serde::{Serialize, Deserialize};
 
-use crate::{input::{Input, IoOptions}, db::{lists_get, userlist_get_all_ids, lists_get_all_ids, lists_insert}, config::Cfg, Modloader, List, devdir, error::MLE, mods_add};
+use crate::{input::{Input, IoOptions}, db::{lists_get, userlist_get_all_ids, lists_get_all_ids, lists_insert}, config::Cfg, Modloader, List, devdir, error::MLE, mods_add, IDSelector};
 
 #[derive(Debug, Serialize, Deserialize)]
 struct Export {
@@ -82,7 +82,7 @@ async fn import(config: Cfg, input: Input) -> MLE<()> {
         let mods: Vec<&str> = exportlist.mods.split('|').collect();
         let mut mod_ids = vec![];
         for mod_id in mods {
-            mod_ids.push(String::from(mod_id));
+            mod_ids.push(IDSelector::ModificationID(String::from(mod_id)));
         };
         //TODO impl set_version and good direct download
         //TODO impl all at once, dafuck
diff --git a/src/commands/modification.rs b/src/commands/modification.rs
index 12a635f..c815155 100644
--- a/src/commands/modification.rs
+++ b/src/commands/modification.rs
@@ -1,8 +1,10 @@
-use crate::{modrinth::{project, versions, extract_current_version, Version, projects}, config::Cfg, db::{mods_insert, userlist_remove, mods_get_id, userlist_insert, userlist_get_all_ids, userlist_get_current_version, lists_get_all_ids, mods_remove}, input::{Input, ModOptions}, files::{delete_version, download_versions}, List, error::{MLE, ErrorType, MLError}};
+use crate::{modrinth::{versions, extract_current_version, Version, projects, get_raw_versions, project}, config::Cfg, db::{mods_insert, userlist_remove, mods_get_id, userlist_insert, userlist_get_all_ids, userlist_get_current_version, lists_get_all_ids, mods_remove}, input::{Input, ModOptions}, files::{delete_version, download_versions}, List, error::{MLE, ErrorType, MLError}};
 
 //TODO DO IT
-pub struct ModVer {
-
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IDSelector {
+    ModificationID(String),
+    VersionID(String)
 }
 
 pub async fn modification(config: Cfg, input: Input) -> MLE<()> {
@@ -22,27 +24,148 @@ async fn add(config: Cfg, input: Input) -> MLE<()> {
 
     Ok(())
 }
-//TODO impl specific version
-pub async fn mods_add(config: Cfg, mod_id: Vec<String>, list: List, direct_download: bool, set_version: bool) -> MLE<()> {
-    
+
+#[derive(Debug, Clone)]
+pub struct ProjectInfo {
+    pub mod_id: String,
+    pub slug: String,
+    pub title: String,
+    pub current_version: Option<Version>,
+    pub applicable_versions: Vec<String>,
+    pub download_link: String,
+}
+
+//TODO impl specific version... Rewrite yay
+pub async fn mods_add(config: Cfg, ids: Vec<IDSelector>, list: List, direct_download: bool, set_version: bool) -> MLE<()> {
     println!("Add mods to {}", list.id);
     println!("  └Add mods:");
-    let projects = if mod_id.len() == 1 {
-        vec![project(String::from(&config.apis.modrinth), &mod_id[0]).await]
-    } else {
-        projects(String::from(&config.apis.modrinth), mod_id).await
-    };
+    
+    let mut mod_ids: Vec<String> = Vec::new();
+    let mut ver_ids: Vec<String> = Vec::new();
+
+    //"Sort" project ids from version ids to be able to handle them differently but in a batch
+    for id in ids {
+        match id {
+            IDSelector::ModificationID(pid) => mod_ids.push(pid),
+            IDSelector::VersionID(vid) => ver_ids.push(vid),
+        }
+    }
 
-    let mut downloadstack: Vec<Version> = Vec::new();
+    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?) };
+    if !ver_ids.is_empty() { projectinfo.append(&mut get_ver_info(config.clone(), ver_ids).await?) };
+
+    if projectinfo.is_empty() { return Err(MLError::new(ErrorType::ArgumentError, "NO_IDS?")) };
     
-    for project in projects {
+    let mut downloadstack: Vec<Version> = Vec::new();
+
+    //Adding each mod to the lists and downloadstack
+    for project in projectinfo {
+        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(), &list.id, &project.mod_id, &current_version_id, project.clone().applicable_versions, &project.download_link, set_version) {
+            Err(e) => {
+                let expected_err = format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
+                if e.to_string() == expected_err { Err(MLError::new(ErrorType::ModError, "MOD_ALREADY_ON_SELECTED_LIST")) } else { Err(e) }
+            },
+            Ok(..) => { Ok(..) },
+        }?;
+        
+        match mods_insert(config.clone(), &project.mod_id, &project.slug, &project.title) {
+            Err(e) => {
+                if e.to_string() == "SQL: UNIQUE constraint failed: mods.id" { Ok(..) } else { Err(e) }
+            },
+            Ok(..) => Ok(..),
+        }?;
+
+        if project.current_version.is_some() { downloadstack.push(project.current_version.unwrap()) };
+    }
+
+    //Download all the added mods
+    if direct_download { 
+        download_versions(list.clone(), config.clone(), downloadstack).await?;
+    };
+
+
+   // let projects = if id.len() == 1 {
+   //     vec![project(String::from(&config.apis.modrinth), &mod_id).await]
+   // } else {
+   //     projects(String::from(&config.apis.modrinth), &mod_id).await
+   // };
+//
+//    let mut downloadstack: Vec<Version> = Vec::new();
+//    
+//    for project in projects {
+//        println!("\t└{}", project.title);
+//        println!("\t  └Get versions");
+//        let available_versions = versions(String::from(&config.apis.modrinth), String::from(&project.id), list.clone()).await;
+//
+//        let mut available_versions_vec: Vec<String> = Vec::new();
+//        let current_version: Option<Version>;
+//        let current_version_id: String;
+//        let file: String;
+//        if !available_versions.is_empty() {
+//            let current_id = extract_current_version(available_versions.clone())?;
+//            println!("\t  └Current version: {}", current_id);
+//
+//            current_version = Some(available_versions.clone().into_iter().find(|v| v.id == current_id).unwrap());
+//
+//            current_version_id = current_version.clone().unwrap().id;
+//
+//            file = current_version.clone().ok_or("").unwrap().files.into_iter().find(|f| f.primary).unwrap().url;
+//            for ver in available_versions {
+//                available_versions_vec.push(ver.id);
+//            };
+//        } else {
+//            println!("\t  └There's currently no mod version for your specified target");
+//            current_version = None;
+//            current_version_id = String::from("NONE");
+//            file = String::from("NONE");
+//            available_versions_vec.push(String::from("NONE"));
+//        }
+//
+//        match userlist_insert(config.clone(), &list.id, &project.id, &current_version_id, available_versions_vec, &file, set_version) {
+//            Err(e) => {
+//                let expected_err = format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
+//                if e.to_string() == expected_err { Err(MLError::new(ErrorType::ModError, "MOD_ALREADY_ON_SELECTED_LIST")) } else { Err(e) }
+//            },
+//            Ok(..) => { Ok(..) },
+//        }?;
+//        
+//        match mods_insert(config.clone(), &project.id, &project.slug, &project.title) {
+//            Err(e) => {
+//                if e.to_string() == "SQL: UNIQUE constraint failed: mods.id" { Ok(..) } else { Err(e) }
+//            },
+//            Ok(..) => Ok(..),
+//        }?;
+//
+//        downloadstack.push(current_version.unwrap());
+//    };
+//
+//    //Download all the added mods
+//    if direct_download { 
+//        download_versions(list.clone(), config.clone(), downloadstack).await?;
+//    };
+//
+    Ok(())
+}
+
+async fn get_mod_infos(config: Cfg, mod_ids: Vec<String>, list: List) -> MLE<Vec<ProjectInfo>> {
+    let mut projectinfo: Vec<ProjectInfo> = Vec::new();
+
+    //Get required information from mod_ids
+    let m_projects = match mod_ids.len() {
+        1 => vec![project(&config.apis.modrinth, &mod_ids[0]).await],
+        2.. => projects(&config.apis.modrinth, mod_ids).await,
+        _ => panic!("PANIC"),
+    };
+    for project in m_projects {
         println!("\t└{}", project.title);
         println!("\t  └Get versions");
-        let available_versions = versions(String::from(&config.apis.modrinth), String::from(&project.id), list.clone()).await;
+        let available_versions = versions(&config.apis.modrinth, String::from(&project.id), list.clone()).await;
 
         let mut available_versions_vec: Vec<String> = Vec::new();
         let current_version: Option<Version>;
-        let current_version_id: String;
         let file: String;
         if !available_versions.is_empty() {
             let current_id = extract_current_version(available_versions.clone())?;
@@ -50,49 +173,55 @@ pub async fn mods_add(config: Cfg, mod_id: Vec<String>, list: List, direct_downl
 
             current_version = Some(available_versions.clone().into_iter().find(|v| v.id == current_id).unwrap());
 
-            current_version_id = current_version.clone().unwrap().id;
-
             file = current_version.clone().ok_or("").unwrap().files.into_iter().find(|f| f.primary).unwrap().url;
             for ver in available_versions {
                 available_versions_vec.push(ver.id);
             };
+
+            projectinfo.push(ProjectInfo { mod_id: project.id, slug: project.slug, title: project.title, current_version, applicable_versions: available_versions_vec, download_link: file })
+
         } else {
             println!("\t  └There's currently no mod version for your specified target");
             current_version = None;
-            current_version_id = String::from("NONE");
             file = String::from("NONE");
             available_versions_vec.push(String::from("NONE"));
+            projectinfo.push(ProjectInfo { mod_id: project.id, slug: project.slug, title: project.title, current_version, applicable_versions: available_versions_vec, download_link: file })
         }
+    };
 
-        match userlist_insert(config.clone(), &list.id, &project.id, &current_version_id, available_versions_vec, &file, set_version) {
-            Err(e) => {
-                let expected_err = format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
-                if e.to_string() == expected_err { Err(MLError::new(ErrorType::ModError, "MOD_ALREADY_ON_SELECTED_LIST")) } else { Err(e) }
-            },
-            Ok(..) => { Ok(..) },
-        }?;
-        
-        match mods_insert(config.clone(), &project.id, &project.slug, &project.title) {
-            Err(e) => {
-                if e.to_string() == "SQL: UNIQUE constraint failed: mods.id" { Ok(..) } else { Err(e) }
-            },
-            Ok(..) => Ok(..),
-        }?;
+    Ok(projectinfo)
+}
 
-        downloadstack.push(current_version.unwrap());
+async fn get_ver_info(config: Cfg, ver_ids: Vec<String>) -> MLE<Vec<ProjectInfo>> {
+    let mut projectinfo: Vec<ProjectInfo> = Vec::new();
+    
+    //Get required information from ver_ids
+    let mut v_versions = get_raw_versions(&config.apis.modrinth, ver_ids).await;
+    let mut v_mod_ids: Vec<String> = Vec::new();
+    for ver in v_versions.clone() {
+        v_mod_ids.push(ver.project_id);
     };
-
-    //Download all the added mods
-    if direct_download { 
-        download_versions(list.clone(), config.clone(), downloadstack).await?;
+    let mut v_projects = projects(&config.apis.modrinth, v_mod_ids).await;
+    v_versions.sort_by(|a, b| a.project_id.cmp(&b.project_id));
+    v_projects.sort_by(|a, b| a.id.cmp(&b.id));
+
+    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;
+        projectinfo.push(ProjectInfo { mod_id: project.id, slug: project.slug, title: project.title, current_version: Some(version.clone()), applicable_versions: vec![String::from(&version.id)], download_link: file })
     };
-
-    Ok(())
+    Ok(projectinfo)
 }
 
 fn remove(config: Cfg, input: Input) -> MLE<()> {
-
-    let mod_id = mods_get_id(&config.data, input.mod_id.as_ref().unwrap())?;
+    
+    let id = match input.clone().mod_id.unwrap() {
+        IDSelector::ModificationID(id) => id,
+        IDSelector::VersionID(..) => return Err(MLError::new(ErrorType::ArgumentError, "NO_MOD_ID")),
+    }; 
+    
+    let mod_id = mods_get_id(&config.data, &id)?;
     
     let version = userlist_get_current_version(config.clone(), input.clone().list.unwrap().id, String::from(&mod_id))?;
 
diff --git a/src/commands/update.rs b/src/commands/update.rs
index bc5b316..75bee39 100644
--- a/src/commands/update.rs
+++ b/src/commands/update.rs
@@ -1,4 +1,4 @@
-use crate::{config::Cfg, modrinth::{versions, extract_current_version, Version}, get_current_list, db::{userlist_get_all_ids, userlist_get_applicable_versions, userlist_change_versions, lists_get_all_ids, lists_get, userlist_get_current_version, mods_get_title, userlist_get_set_version}, List, input::Input, files::{delete_version, download_versions, disable_version, clean_list_dir}, error::{MLE, MLError, ErrorType}};
+use crate::{config::Cfg, modrinth::{versions, extract_current_version, Version}, get_current_list, db::{userlist_get_all_ids, userlist_get_applicable_versions, userlist_change_versions, lists_get_all_ids, lists_get, userlist_get_current_version, userlist_get_set_version, mods_get_info}, List, input::Input, files::{delete_version, download_versions, disable_version, clean_list_dir}, error::{MLE, MLError, ErrorType}};
 
 pub async fn update(config: Cfg, input: Input) -> MLE<()> {
     let mut liststack: Vec<List> = vec![];
@@ -25,8 +25,8 @@ pub async fn cmd_update(config: Cfg, liststack: Vec<List>, clean: bool, direct_d
         let mut updatestack: Vec<Version> = vec![];
         
         for id in mods {
-            let title = mods_get_title(config.clone(), &id)?;
-            println!("\t└{}", title);
+            let info = mods_get_info(config.clone(), &id)?;
+            println!("\t└{}", info.title);
 
             if userlist_get_set_version(config.clone(), &current_list.id, &id)? {
                 println!("\t  └Set version, skipping update");
@@ -78,7 +78,7 @@ pub async fn cmd_update(config: Cfg, liststack: Vec<List>, clean: bool, direct_d
 }
 
 async fn specific_update(config: Cfg, clean: bool, list: List, id: String) -> MLE<Version> {
-    let applicable_versions = versions(String::from(&config.apis.modrinth), String::from(&id), list.clone()).await;
+    let applicable_versions = versions(&config.apis.modrinth, String::from(&id), list.clone()).await;
     
     let mut versions: Vec<String> = vec![];