use std::collections::HashMap;
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
use crate::{
apis::modrinth::{extract_current_version, get_raw_versions, project, projects, versions, Version}, config::Cfg, data::{modification::{AddMod, IDSelector}, project::ProjectInfo}, db::{
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::{EType, MLErr, MLE}, files::{delete_version, download_versions}, List, PROGRESS_CHARS, STYLE_BAR_POS, STYLE_OPERATION
};
/// # Errors
pub async fn mod_add(
config: &Cfg,
mods: Vec<AddMod>,
list: List,
direct_download: bool,
) -> MLE<()> {
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()
.map_err(|_| MLErr::new(EType::Other, "MODSLENTRY"))?,
));
add_p.set_style(
ProgressStyle::with_template(STYLE_BAR_POS)
.map_err(|_| MLErr::new(EType::LibIndicatif, "template error"))?
.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::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, mod_ids, list.clone()).await?);
};
if !ver_ids.is_empty() {
projectinfo.append(&mut get_ver_info(config, ver_ids).await?);
};
if projectinfo.is_empty() {
return Err(MLErr::new(EType::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
let project_p = mp.insert_before(
&add_p,
ProgressBar::new(
projectinfo
.len()
.try_into()
.map_err(|_| MLErr::new(EType::Other, "infolen"))?,
),
);
project_p.set_style(
ProgressStyle::with_template(STYLE_BAR_POS)
.map_err(|_| MLErr::new(EType::LibIndicatif, "template error"))?
.progress_chars(PROGRESS_CHARS),
);
for project in projectinfo {
add_project(config, &project_p, &project, &list)?;
if project.current_version.is_some() {
downloadstack.push(
project
.current_version
.ok_or(MLErr::new(EType::Other, "cur_ver"))?,
);
};
}
project_p.finish_with_message("Added all mods to the database");
//Download all the added mods
if direct_download {
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(())
}
fn add_project(
config: &Cfg,
project_p: &ProgressBar,
project: &ProjectInfo,
list: &List,
) -> MLE<()> {
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()
.ok_or(MLErr::new(EType::Other, "cur_ver"))?
.id
};
match userlist_insert(
config,
&list.id,
&project.mod_id,
¤t_version_id,
&project.applicable_versions,
&project.download_link,
project.set_version,
) {
Err(e) => {
let expected_err =
format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
if e.to_string() == expected_err {
Err(MLErr::new(EType::ModError, "MOD_ALREADY_ON_SELECTED_LIST"))
} else {
Err(e)
}
}
Ok(..) => Ok(..),
}?;
match mods_insert(config, &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(..),
}?;
project_p.inc(1);
Ok(())
}
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![];
for id in mod_ids {
setmap.insert(id.0.to_string(), id.1);
ids.push(id.0);
}
let mut projectinfo: Vec<ProjectInfo> = Vec::new();
//Get required information from mod_ids
let m_projects = match ids.len() {
1 => vec![project(&config.apis.modrinth, &ids[0]).await?],
2.. => projects(&config.apis.modrinth, ids).await?,
_ => panic!("PANIC"),
};
for project in m_projects {
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 file: String;
if available_versions.is_empty() {
current_version = None;
file = String::from("NONE");
available_versions_vec.push(String::from("NONE"));
projectinfo.push(ProjectInfo {
mod_id: String::from(&project.id),
slug: project.slug,
title: project.title,
current_version,
applicable_versions: available_versions_vec,
download_link: file,
set_version: *setmap
.get(&project.id)
.ok_or(MLErr::new(EType::Other, "not in setmap"))?,
});
} else {
let current_id =
extract_current_version(available_versions.clone())?;
current_version = Some(
available_versions
.clone()
.into_iter()
.find(|v| v.id == current_id)
.unwrap(),
);
// match primary, if none?
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;
for ver in available_versions {
available_versions_vec.push(ver.id);
}
projectinfo.push(ProjectInfo {
mod_id: String::from(&project.id),
slug: project.slug.clone(),
title: project.title,
current_version,
applicable_versions: available_versions_vec,
download_link: file,
set_version: *setmap.get(&project.slug).unwrap(),
});
}
}
Ok(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![];
for id in ver_ids {
setmap.insert(id.0.to_string(), id.1);
ids.push(id.0);
}
let mut projectinfo: Vec<ProjectInfo> = Vec::new();
//Get required information from ver_ids
let mut v_versions = get_raw_versions(&config.apis.modrinth, ids).await?;
let mut v_mod_ids: Vec<String> = Vec::new();
for ver in v_versions.clone() {
v_mod_ids.push(ver.project_id);
}
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];
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,
title: project.title,
current_version: Some(version.clone()),
applicable_versions: vec![String::from(&version.id)],
download_link: file,
set_version: *setmap.get(&version.id).unwrap(),
});
}
Ok(projectinfo)
}
/// Remove mod from a list
/// # Arguments
///
/// * `config` - config struct
/// * `id` - name, slug or id of the mod
/// * `list` - List struct
///
/// # Errors
pub fn mod_remove(config: &Cfg, id: &str, list: &List) -> MLE<()> {
let progress = ProgressBar::new_spinner();
progress.set_style(
ProgressStyle::with_template(STYLE_OPERATION)
.map_err(|_| MLErr::new(EType::LibIndicatif, "template error"))?,
);
let mod_id = mods_get_id(&config.data, id)?;
let info = mods_get_info(config, &mod_id)?;
progress.set_message(format!("Remove {} from {}", info.title, list.id));
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"
{
return Err(err);
};
}
};
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, &id) {
Ok(m) => m,
Err(err) => {
if err.to_string() == "Database: NO_MODS_USERLIST" {
return Ok(());
};
return Err(err);
}
};
if mods.contains(&mod_id) {
mod_used = true;
break;
};
}
if !mod_used {
progress.set_message("Remove from main list");
mods_remove(config, &mod_id)?;
};
progress.finish_with_message(format!(
"Removed {} from {}",
info.title, list.id
));
Ok(())
}