9 files changed, 184 insertions, 71 deletions

diff --git a/Cargo.lock b/Cargo.lock
index f25b161..7422038 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -798,7 +798,7 @@ dependencies = [
 
 [[package]]
 name = "modlist"
-version = "0.13.1"
+version = "0.14.1"
 dependencies = [
  "chrono",
  "clap",
diff --git a/Cargo.toml b/Cargo.toml
index 7b6466f..bd41811 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "modlist"
-version = "0.13.1"
+version = "0.14.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/src/apis/modrinth.rs b/src/apis/modrinth.rs
index 9afe7f3..525cc0d 100644
--- a/src/apis/modrinth.rs
+++ b/src/apis/modrinth.rs
@@ -1,10 +1,10 @@
 use chrono::{DateTime, FixedOffset};
 use reqwest::Client;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 use crate::{
     error::{ErrorType, MLError, MLE},
-    List, Modloader,
+    List,
 };
 
 #[derive(Debug, Deserialize, Clone)]
@@ -113,7 +113,24 @@ pub struct Hash {
     pub sha1: String,
 }
 
-async fn get(api: &str, path: String) -> Result<Option<Vec<u8>>, Box<dyn std::error::Error>> {
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GameVersion {
+    pub version: String,
+    pub version_type: GameVersionType,
+    pub date: String,
+    pub major: bool,
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum GameVersionType {
+    release,
+    snapshot,
+    alpha,
+    beta
+}
+
+async fn get(api: &str, path: &str) -> Result<Option<Vec<u8>>, Box<dyn std::error::Error>> {
     let url = format!(r#"{}{}"#, api, path);
 
     let client = Client::builder()
@@ -135,7 +152,7 @@ async fn get(api: &str, path: String) -> Result<Option<Vec<u8>>, Box<dyn std::er
 
 pub async fn project(api: &str, name: &str) -> Project {
     let url = format!("project/{}", name);
-    let data = get(api, url).await.unwrap().unwrap();
+    let data = get(api, &url).await.unwrap().unwrap();
 
     serde_json::from_slice(&data).unwrap()
 }
@@ -144,24 +161,19 @@ pub async fn projects(api: &str, ids: Vec<String>) -> Vec<Project> {
     let all = ids.join(r#"",""#);
     let url = format!(r#"projects?ids=["{}"]"#, all);
 
-    let data = get(api, url).await.unwrap().unwrap();
+    let data = get(api, &url).await.unwrap().unwrap();
 
     serde_json::from_slice(&data).unwrap()
 }
 
 ///Get applicable versions from mod_id with list context
 pub async fn versions(api: &str, id: String, list: List) -> Vec<Version> {
-    let loaderstr = match list.modloader {
-        Modloader::Forge => String::from("forge"),
-        Modloader::Fabric => String::from("fabric"),
-    };
-
     let url = format!(
         r#"project/{}/version?loaders=["{}"]&game_versions=["{}"]"#,
-        id, loaderstr, list.mc_version
+        id, list.modloader.to_string(), list.mc_version
     );
 
-    let data = get(api, url).await.unwrap();
+    let data = get(api, &url).await.unwrap();
 
     match data {
         Some(data) => serde_json::from_slice(&data).unwrap(),
@@ -173,7 +185,7 @@ pub async fn versions(api: &str, id: String, list: List) -> Vec<Version> {
 pub async fn get_raw_versions(api: &str, versions: Vec<String>) -> Vec<Version> {
     let url = format!(r#"versions?ids=["{}"]"#, versions.join(r#"",""#));
 
-    let data = get(api, url).await.unwrap().unwrap();
+    let data = get(api, &url).await.unwrap().unwrap();
 
     serde_json::from_slice(&data).unwrap()
 }
@@ -195,39 +207,8 @@ pub fn extract_current_version(versions: Vec<Version>) -> MLE<String> {
     }
 }
 
-pub enum MCVersionType {
-    Release,
-    Latest,
-    Specific,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct MCVersion {
-    pub version: String,
-    pub version_type: String,
-    pub date: String,
-    pub major: bool,
-}
+pub async fn get_game_versions() -> Vec<GameVersion> {
+    let data = get("https://api.modrinth.com/v2/", "tag/game_version").await.unwrap().unwrap();
 
-pub async fn get_minecraft_version(api: &str, version: MCVersionType) -> String {
-    let data = get(api, String::from("tag/game_version"))
-        .await
-        .unwrap()
-        .unwrap();
-    let mc_versions: Vec<MCVersion> = serde_json::from_slice(&data).unwrap();
-    let ver = match version {
-        MCVersionType::Release => {
-            let mut i = 0;
-            while !mc_versions[i].major {
-                i += 1;
-            }
-            &mc_versions[i]
-        }
-        MCVersionType::Latest => &mc_versions[0],
-        MCVersionType::Specific => {
-            println!("Not inplemented");
-            &mc_versions[0]
-        }
-    };
-    String::from(&ver.version)
+    serde_json::from_slice(&data).unwrap()
 }
diff --git a/src/commands/io.rs b/src/commands/io.rs
index 82b30ce..e072f00 100644
--- a/src/commands/io.rs
+++ b/src/commands/io.rs
@@ -92,7 +92,7 @@ pub async fn import(config: Cfg, file_str: String, direct_download: bool) -> MLE
             mod_ids.push(IDSelector::ModificationID(String::from(mod_id)));
         }
         //TODO impl set_version and good direct download
-        //TODO impl all at once, dafuck
+        //TODO impl all at once, dafuck ?done?
         mod_add(config.clone(), mod_ids, list, direct_download, false).await?;
     }
     Ok(())
diff --git a/src/config.rs b/src/config.rs
index 61db1c7..e1049d1 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -6,12 +6,14 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
-use crate::{db::db_setup, error::MLE};
+use crate::{db::db_setup, error::MLE, Modloader, VersionLevel, check_game_versions};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Cfg {
     pub data: String,
     pub cache: String,
+    pub versions: String,
+    pub defaults: Defaults,
     pub apis: Apis,
 }
 
@@ -20,13 +22,20 @@ pub struct Apis {
     pub modrinth: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Defaults {
+    pub modloader: Modloader,
+    pub version: VersionLevel,
+}
+
 impl Cfg {
-    pub fn init(path: Option<String>) -> MLE<Self> {
+    pub async fn init(path: Option<String>) -> MLE<Self> {
         let configfile = match path.clone() {
             Some(p) => String::from(p),
             None => dirs::config_dir()
                 .unwrap()
-                .join("modlist.toml")
+                .join("modlist")
+                .join("config.toml")
                 .to_string_lossy()
                 .to_string(),
         };
@@ -50,12 +59,20 @@ impl Cfg {
             create_cache(&config.cache)?;
         };
         //Check database
-        //TODO check file
         let datafile = format!("{}/data.db", config.data);
         match File::open(&datafile) {
             Ok(..) => (),
             Err(..) => create_database(&datafile)?,
         };
+        //Check versions
+        let versionfile = format!("{}/versions.json", config.versions);
+        match File::open(&versionfile) {
+            Ok(..) => (),
+            Err(..) => {
+                create_versions_dummy(&versionfile).await?;
+                check_game_versions(&versionfile, true).await?;
+            },
+        }
         Ok(config)
     }
 }
@@ -64,14 +81,24 @@ fn create_config(path: &str) -> MLE<()> {
     print!("No config file found, create default");
     //Force flush of stdout, else print! doesn't print instantly
     std::io::stdout().flush()?;
+    let cache_dir = dirs::cache_dir()
+        .unwrap()
+        .join("modlist")
+        .to_string_lossy()
+        .to_string();
     let default_cfg = Cfg {
-        //TODO get home dir
-        data: String::from("$HOME/.cache/modlist/"),
-        cache: String::from("$HOME/.cache/modlist/cache"),
+        data: cache_dir.clone(),
+        cache: format!("{}/cache", cache_dir),
+        versions: cache_dir.clone(),
+        defaults: Defaults {
+            modloader: Modloader::Fabric,
+            version: VersionLevel::Release
+        },
         apis: Apis {
             modrinth: String::from("https://api.modrinth.com/v2/"),
         },
     };
+    create_dir_all(path.split("config.toml").collect::<Vec<&str>>()[0])?;
     let mut file = File::create(path)?;
     file.write_all(toml::to_string(&default_cfg)?.as_bytes())?;
     println!(" ✓");
@@ -98,3 +125,13 @@ fn create_cache(path: &str) -> MLE<()> {
     println!(" ✓");
     Ok(())
 }
+
+async fn create_versions_dummy(path: &str) -> MLE<()> {
+    print!("No version file found, create dummy");
+    //Force flush of stdout, else print! doesn't print instantly
+    std::io::stdout().flush()?;
+
+    File::create(path)?;
+    println!(" ✓");
+    Ok(())
+}
diff --git a/src/db.rs b/src/db.rs
index abfe1dd..6c7e4f8 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -50,8 +50,6 @@ pub fn mods_get_all_ids(config: Cfg) -> Result<Vec<String>, Box<dyn std::error::
 ///
 ///Will return `MLError` when no mod id is found
 pub fn mods_get_id(data: &str, slug: &str) -> MLE<String> {
-    //TODO check if "slug" is id
-
     let data = format!("{}/data.db", data);
     let connection = Connection::open(data)?;
 
@@ -64,6 +62,15 @@ pub fn mods_get_id(data: &str, slug: &str) -> MLE<String> {
     for id in id_iter {
         mod_id = id?;
     }
+    //get from id if no slug found
+    if mod_id.is_empty() {
+        let mut stmt = connection.prepare("SELECT id FROM mods WHERE id = ?")?;
+        let id_iter = stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
+
+        for id in id_iter {
+            mod_id = id?;
+        }
+    }
     //get from title if no id found from slug
     if mod_id.is_empty() {
         let mut stmt = connection.prepare("SELECT id FROM mods WHERE title = ?")?;
diff --git a/src/error.rs b/src/error.rs
index bd6e3da..e6afeaa 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -20,6 +20,7 @@ pub enum ErrorType {
     LibSql,
     LibReq,
     LibChrono,
+    LibJson,
     IoError,
     Other,
 }
@@ -42,6 +43,7 @@ impl fmt::Display for MLError {
             ErrorType::LibSql => write!(f, "SQL: {}", self.message),
             ErrorType::LibReq => write!(f, "REQWEST"),
             ErrorType::LibChrono => write!(f, "Chrono error: {}", self.message),
+            ErrorType::LibJson => write!(f, "JSON: {}", self.message),
             ErrorType::IoError => write!(f, "IO"),
             ErrorType::Other => write!(f, "OTHER"),
         }
@@ -102,6 +104,13 @@ impl From<std::io::Error> for MLError {
     }
 }
 
+impl From<serde_json::error::Error> for MLError {
+    fn from(value: serde_json::error::Error) -> Self {
+        Self { etype: ErrorType::LibJson, message: value.to_string() }
+    }
+    
+}
+
 impl MLError {
     pub fn new(etype: ErrorType, message: &str) -> Self {
         Self {
diff --git a/src/lib.rs b/src/lib.rs
index 185edd7..f18bdfb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,16 +6,22 @@ pub mod db;
 pub mod error;
 pub mod files;
 
-use std::fmt::Display;
+use std::{fmt::Display, fs::{File, remove_file, self}, io::{Write, Read}, time::Duration};
 
 pub use apis::*;
+use apis::modrinth::{get_game_versions, GameVersion, GameVersionType};
 pub use commands::*;
 use error::{ErrorType, MLError, MLE};
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Modloader {
+    #[serde(rename(serialize = "fabric", deserialize = "fabric"))]
     Fabric,
+    #[serde(rename(serialize = "forge", deserialize = "forge"))]
     Forge,
+    #[serde(rename(serialize = "quilt", deserialize = "quilt"))]
+    Quilt,
 }
 
 impl Modloader {
@@ -33,6 +39,77 @@ impl Display for Modloader {
         match self {
             Modloader::Fabric => write!(f, "fabric"),
             Modloader::Forge => write!(f, "forge"),
+            Modloader::Quilt => write!(f, "quilt"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum VersionLevel {
+    #[serde(rename(serialize = "release", deserialize = "release"))]
+    Release,
+    #[serde(rename(serialize = "snapshot", deserialize = "snapshot"))]
+    Snapshot,
+    Version(String)
+}
+
+/// Checks if update needed (time)
+/// if yes: get versions, update
+pub async fn check_game_versions(path: &str, force: bool) -> MLE<()> {
+    let creation_time = fs::metadata(path)?.created()?;
+    if !force && creation_time.elapsed().unwrap() < Duration::from_secs(60 * 60 * 24) { return Ok(()); }
+    print!("Update minecraft versions");
+    std::io::stdout().flush()?;
+    let versions = get_game_versions().await;
+    remove_file(path)?;
+    let mut file = File::create(path)?;
+    file.write_all(&serde_json::to_string_pretty(&versions)?.as_bytes())?;
+    println!(" ✓");
+    Ok(())
+}
+
+/// Loads game versions from file
+pub fn load_game_versions(path: &str) -> MLE<Vec<GameVersion>> {
+    let mut file = File::open(path)?;
+    let mut data = String::new();
+    file.read_to_string(&mut data)?;
+    let versions: Vec<GameVersion> = serde_json::from_str(&data)?;
+    Ok(versions)
+}
+
+impl VersionLevel {
+
+    pub fn from(str: &str) -> Self {
+        match str {
+            "release" => VersionLevel::Release,
+            "snapshot" => VersionLevel::Snapshot,
+            _ => VersionLevel::Version(String::from(str)),
+        }
+    }
+
+    pub async fn get(self, versions_path: &str, force_update: bool) -> MLE<String> {
+        let path = format!("{}/versions.json", versions_path);
+        check_game_versions(&path, force_update).await?;
+        let mut versions = load_game_versions(&path)?.into_iter();
+
+        match self {
+            VersionLevel::Release => {
+                let release = versions.find(|ver| ver.version_type == GameVersionType::release).unwrap();
+                println!("{:?}", release);
+                Ok(release.version)
+            },
+            VersionLevel::Snapshot => {
+                let snapshot = versions.find(|ver| ver.version_type == GameVersionType::snapshot).unwrap();
+                println!("{:?}", snapshot);
+                Ok(snapshot.version)
+            },
+            VersionLevel::Version(v) => {
+                if versions.find(|ver| ver.version == v).is_some() {
+                    Ok(v)
+                } else {
+                    Err(MLError::new(ErrorType::ConfigError, "unknown minecraft version"))
+                }
+            },
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 53cbe71..3bc2ba0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,11 +3,9 @@ use modlist::{
     config::Cfg,
     db::{config_get_current_list, lists_get, lists_get_all_ids},
     download, export, get_current_list, import, list_add, list_change, list_remove, list_version,
-    mod_add, mod_remove, update, IDSelector, List, Modloader,
+    mod_add, mod_remove, update, IDSelector, List, Modloader, VersionLevel,
 };
 
-//TODO implement remote sql db
-
 //TODO make default list optional
 #[derive(Parser)]
 #[command(author, version, about)]
@@ -18,6 +16,10 @@ struct Cli {
     /// config file path
     #[arg(short, long)]
     config: Option<String>,
+
+    /// Force GameVersion update
+    #[arg(long)]
+    force_gameupdate: bool,
 }
 
 #[derive(Subcommand)]
@@ -72,6 +74,7 @@ enum Commands {
         /// the list you want to export
         list: Option<String>,
     },
+    Test
 }
 
 #[derive(Subcommand)]
@@ -147,7 +150,7 @@ enum ListCommands {
 async fn main() {
     let cli = Cli::parse();
 
-    let config = Cfg::init(cli.config).unwrap();
+    let config = Cfg::init(cli.config).await.unwrap();
 
     match cli.command {
         Commands::Mod { command } => {
@@ -201,15 +204,13 @@ async fn main() {
                 } => {
                     let ml = match modloader {
                         Some(ml) => Modloader::from(&ml).unwrap(),
-                        //TODO add default modloader to config
-                        None => Modloader::Fabric,
+                        None => config.clone().defaults.modloader,
                     };
 
+                    let versions_path = &config.versions;
                     let ver = match version {
-                        Some(ver) => ver,
-                        //TODO get latest version
-                        //TODO impl config for specific version or latest or latest snap
-                        None => "1.19.4".to_string(),
+                        Some(ver) => VersionLevel::from(&ver).get(versions_path, cli.force_gameupdate).await.unwrap(),
+                        None => config.clone().defaults.version.get(versions_path, cli.force_gameupdate).await.unwrap(),
                     };
 
                     list_add(config, id, ver, ml, directory)
@@ -263,6 +264,7 @@ async fn main() {
             import(config, filestr, download).await
         }
         Commands::Export { list } => export(config, list),
+        Commands::Test => Ok(()),
     }
     .unwrap();
 }