7 files changed, 203 insertions, 268 deletions

diff --git a/src/commands/download.rs b/src/commands/download.rs
index 05c54cb..993294b 100644
--- a/src/commands/download.rs
+++ b/src/commands/download.rs
@@ -4,12 +4,12 @@ use reqwest::Client;
 
 use futures_util::StreamExt;
 
-use crate::{get_current_list, config::Cfg, db::get_dl_links};
+use crate::{get_current_list, config::Cfg, db::userlist_get_all_downloads};
 
 pub async fn download(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
     let list = get_current_list(config.clone())?;
 
-    let links = get_dl_links(config.clone(), list)?;
+    let links = userlist_get_all_downloads(config.clone(), list.id)?;
 
     download_links(config, links).await?;
 
diff --git a/src/commands/list.rs b/src/commands/list.rs
index ffa5926..6c80e4e 100644
--- a/src/commands/list.rs
+++ b/src/commands/list.rs
@@ -1,8 +1,8 @@
 use std::io::{Error, ErrorKind};
 
-use crate::{db::{lists_insert, remove_list, change_list, get_lists, get_current_list_id, get_list}, Modloader, config::Cfg, input::Input};
+use crate::{db::{lists_insert, lists_remove, config_change_current_list, lists_get_all_ids, config_get_current_list, lists_get}, Modloader, config::Cfg, input::Input};
 
-#[derive(Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct List {
     pub id: String,
     pub mc_version: String,
@@ -12,8 +12,8 @@ pub struct List {
 pub fn list(config: Cfg, args: Option<Vec<String>>) -> Result<(), Box<dyn std::error::Error>> {
 
     if args.is_none() {
-        let lists = get_lists(config.clone())?;
-        let current_list = get_current_list_id(config)?;
+        let lists = lists_get_all_ids(config.clone())?;
+        let current_list = config_get_current_list(config)?;
         println!("Your lists:\n{}\n-----\nCurrently selected list: \"{}\"", lists.join(",\n"), current_list);
         return Ok(());
     }
@@ -37,8 +37,8 @@ pub fn list(config: Cfg, args: Option<Vec<String>>) -> Result<(), Box<dyn std::e
 }
 
 pub fn get_current_list(config: Cfg) -> Result<List, Box<dyn std::error::Error>> {
-    let id = get_current_list_id(config.clone())?;
-    get_list(config, id)
+    let id = config_get_current_list(config.clone())?;
+    lists_get(config, id)
 }
 
 fn add(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
@@ -52,10 +52,7 @@ fn add(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>>
                 "fabric" => Modloader::Fabric,
                 _ => return Err(Box::new(Error::new(ErrorKind::InvalidInput, "UNKNOWN_MODLOADER")))
             };
-            match lists_insert(config, id, mc_version, mod_loader) {
-                Err(err) => { Err(Box::new(Error::new(ErrorKind::Other, "TBD"))) },
-                Ok(()) => Ok(()),
-            }
+            lists_insert(config, id, mc_version, mod_loader)
         },
         5.. => Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_MANY_ARGUMENTS"))),
         _ => panic!("list arguments should never be zero or lower"),
@@ -63,13 +60,13 @@ fn add(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>>
 }
 
 fn change(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
-    let lists = get_lists(config.clone())?;
+    let lists = lists_get_all_ids(config.clone())?;
     match args.len() {
         1 => {
             let list = String::from(&args[0]);
             if !lists.contains(&list) { return Err(Box::new(Error::new(ErrorKind::NotFound, "LIST_DOESNT_EXIST"))); };
-            match change_list(config, list) {
-                Err(err) => { Err(Box::new(Error::new(ErrorKind::Other, "TBD"))) },
+            match config_change_current_list(config, list) {
+                Err(..) => { Err(Box::new(Error::new(ErrorKind::Other, "72"))) },
                 Ok(()) => Ok(()),
             }
         },
@@ -81,8 +78,8 @@ fn change(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Erro
 fn remove(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
     match args.len() {
         1 => {
-            match remove_list(config, String::from(&args[0])) {
-                Err(err) => { Err(Box::new(Error::new(ErrorKind::Other, "TBD"))) },
+            match lists_remove(config, String::from(&args[0])) {
+                Err(..) => { Err(Box::new(Error::new(ErrorKind::Other, "85"))) },
                 Ok(()) => Ok(()),
             }
         },
diff --git a/src/commands/modification.rs b/src/commands/modification.rs
index 7836735..595b677 100644
--- a/src/commands/modification.rs
+++ b/src/commands/modification.rs
@@ -22,7 +22,7 @@ pub async fn modification(config: Cfg, args: Option<Vec<String>>) -> Result<(),
 }
 
 async fn add(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
-    
+    //TODO! DO NOT PANIC IF MOD IS ALREADY IN MODS DB
     if args.is_empty() { return Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_FEW_ARGUMENTS"))); };
     
     let current_list = get_current_list(config.clone())?;
diff --git a/src/commands/setup.rs b/src/commands/setup.rs
index 0940959..8c0fcfd 100644
--- a/src/commands/setup.rs
+++ b/src/commands/setup.rs
@@ -1,6 +1,6 @@
 use std::{fs::File, path::Path, io::{Error, ErrorKind}};
 
-use crate::{config::Cfg, db::{db_setup, user_dbversion, create_dbversion, insert_column, get_lists, get_list, get_current_versions, insert_dl_link}, modrinth::get_raw_versions};
+use crate::{config::Cfg, db::{db_setup, s_config_get_version, s_config_create_version, s_insert_column, lists_get_all_ids, lists_get, userlist_get_all_current_version_ids, s_userlist_update_download}, modrinth::get_raw_versions};
 
 pub async fn setup(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
 
@@ -10,7 +10,7 @@ pub async fn setup(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
         return create(config, db_file);
     }
     
-    match user_dbversion(config.clone()) {
+    match s_config_get_version(config.clone()) {
         Ok(ver) => {
             match ver.as_str() {
                 _ => return Err(Box::new(Error::new(ErrorKind::Other, "UNKNOWN_VERSION")))
@@ -29,26 +29,25 @@ fn create(config: Cfg, db_file: String) -> Result<(), Box<dyn std::error::Error>
 }
 
 async fn to_02(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
-    let lists = get_lists(config.clone())?;
+    let lists = lists_get_all_ids(config.clone())?;
 
     for list in lists {
         println!("Updating {}", list);
-        insert_column(config.clone(), String::from(&list), String::from("current_download"), String::new())?;
+        s_insert_column(config.clone(), String::from(&list), String::from("current_download"), String::new())?;
 
-        let full_list = get_list(config.clone(), String::from(&list))?;
+        let full_list = lists_get(config.clone(), String::from(&list))?;
 
-        let versions = get_current_versions(config.clone(), full_list.clone())?;
+        let versions = userlist_get_all_current_version_ids(config.clone(), full_list.clone().id)?;
         
         let raw_versions = get_raw_versions(String::from(&config.apis.modrinth), versions).await;
 
         for ver in raw_versions {
             println!("Adding link for {}", ver.project_id);
             let file = ver.files.into_iter().find(|f| f.primary).unwrap();
-            insert_dl_link(config.clone(), full_list.clone(), ver.project_id, file.url)?;
+            s_userlist_update_download(config.clone(), String::from(&full_list.id), ver.project_id, file.url)?;
         }
     };
-    create_dbversion(config)?;
-
+    s_config_create_version(config)?;
 
     Ok(())
 }
diff --git a/src/commands/update.rs b/src/commands/update.rs
index d278a78..e383eae 100644
--- a/src/commands/update.rs
+++ b/src/commands/update.rs
@@ -4,7 +4,7 @@ use reqwest::Client;
 
 use futures_util::StreamExt;
 
-use crate::{config::Cfg, modrinth::{projects, Project, versions, extract_current_version, Version}, get_current_list, db::{userlist_get_all_ids, get_versions, get_list_version, change_list_versions}, List};
+use crate::{config::Cfg, modrinth::{projects, Project, versions, extract_current_version, Version}, get_current_list, db::{userlist_get_all_ids, mods_get_versions, userlist_get_applicable_versions, userlist_change_versions}, List};
 
 pub async fn update(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
 
@@ -12,7 +12,7 @@ pub async fn update(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
 
     let mods = userlist_get_all_ids(config.clone(), current_list.clone().id)?;
 
-    let mut versions = get_versions(config.clone(), mods.clone())?;
+    let mut versions = mods_get_versions(config.clone(), mods.clone())?;
     versions.sort_by_key(|ver| ver.mod_id.clone());
 
     let mut projects = projects(String::from(&config.apis.modrinth), mods).await;
@@ -54,12 +54,15 @@ async fn specific_update(config: Cfg, list: List, project: Project) -> Result<Ve
     }
     
     let mut current: Vec<Version> = vec![];
-    if versions.join("|") != get_list_version(config.clone(), list.clone(), String::from(&project.id))? {
+    if versions.join("|") != userlist_get_applicable_versions(config.clone(), String::from(&list.id), String::from(&project.id))? {
         //get new versions
         print!(" | getting new version");
         let current_str = extract_current_version(applicable_versions.clone())?;
-        current.push(applicable_versions.into_iter().find(|ver| ver.id == current_str).unwrap());
-        change_list_versions(config, list, current_str, versions, project.id)?;
+        let current_ver = applicable_versions.into_iter().find(|ver| ver.id == current_str).ok_or("")?;
+        current.push(current_ver.clone());
+
+        let link = current_ver.files.into_iter().find(|f| f.primary).ok_or("")?.url;
+        userlist_change_versions(config, list.id, current_str, versions.join("|"), link, project.id)?;
     }
 
     if current.is_empty() { return Err(Box::new(Error::new(ErrorKind::NotFound, "NO_UPDATE_AVAILABLE"))) };
diff --git a/src/db.rs b/src/db.rs
index 86e697e..5d82271 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -2,9 +2,9 @@ use std::io::{Error, ErrorKind};
 
 use rusqlite::Connection;
 
-use crate::{Modloader, config::Cfg, List};
+use crate::{Modloader, config::Cfg, List, get_modloader};
 
-//MODS
+//mods
 pub fn mods_insert(config: Cfg, id: String, name: String, versions: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
 
     println!("Inserting mod {}({}) into database", name, id);
@@ -75,6 +75,43 @@ pub fn mods_remove(config: Cfg, id: String) -> Result<(), Box<dyn std::error::Er
     Ok(())
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DBModlistVersions {
+    pub mod_id: String,
+    pub versions: String,
+}
+
+pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> Result<Vec<DBModlistVersions>, Box<dyn std::error::Error>> {
+    let data = format!("{}/data.db", config.data);
+    let connection = Connection::open(data)?;
+
+    if mods.is_empty() { return Err(Box::new(Error::new(ErrorKind::Other, "MODS_NO_INPUT"))); }
+
+    let mut wherestr = String::from("WHERE");
+    for (i, id) in mods.iter().enumerate() {
+        let mut or = " OR";
+        if i == mods.len() - 1 { or = ""  };
+        wherestr = format!("{} id = '{}'{}", wherestr, id, or);
+    }
+
+    let mut versionmaps: Vec<DBModlistVersions> = Vec::new();
+    let mut stmt = connection.prepare(dbg!(format!("SELECT id, versions FROM mods {}", wherestr).as_str()))?;
+    let id_iter = stmt.query_map([], |row| {
+        Ok(vec![row.get::<usize, String>(0)?, row.get::<usize, String>(1)?])
+    })?;
+
+    for ver in id_iter {
+        let version = ver?;
+        println!("Found versions {} for mod {}", version[1], version[0]);
+        versionmaps.push(DBModlistVersions { mod_id: String::from(&version[0]), versions: String::from(&version[1]) })
+    };
+
+    match versionmaps.is_empty() {
+        true => Err(Box::new(Error::new(ErrorKind::NotFound, "MODS_MODS_NOT_FOUND"))),
+        false => Ok(versionmaps),
+    }
+}
+
 //userlist
 pub fn userlist_insert(config: Cfg, list_id: String, mod_id: String, current_version: String, applicable_versions: Vec<String>, current_link: String) -> Result<(), Box<dyn std::error::Error>> {
     println!("Inserting {} into current list({})", mod_id, list_id);
@@ -119,69 +156,74 @@ pub fn userlist_remove(config: Cfg, list_id: String, mod_id: String) -> Result<(
 }
 
 
-#[derive(Debug, Clone)]
-pub struct DBModlistVersions {
-    pub mod_id: String,
-    pub versions: String,
-}
-
-pub fn get_versions(config: Cfg, mods: Vec<String>) -> Result<Vec<DBModlistVersions>, Box<dyn std::error::Error>> {
-    /*
+pub fn userlist_get_applicable_versions(config: Cfg, list_id: String, mod_id: String) -> Result<String, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
+    let connection = Connection::open(data).unwrap();
 
-    let mut wherestr = String::from("WHERE");
-    for (i, id) in mods.iter().enumerate() {
-        let mut or = " OR";
-        if i == mods.len() - 1 { or = ""  }
-        println!("Pushing {}({}) | OR: '{}'", id, i, or);
-        wherestr = format!("{} id = '{}'{}", wherestr, id, or);
-    }
+    let mut version: String = String::new();
+    let mut stmt = connection.prepare(format!("SELECT applicable_versions FROM {} WHERE mod_id = ?", list_id).as_str())?;
+    let ver_iter = stmt.query_map([mod_id], |row| {
+        row.get::<usize, String>(0)
+    })?;
 
-    let sql = format!("SELECT id, versions FROM mods {}", wherestr);
+    for ver in ver_iter {
+        println!("Found id {:?}", ver);
+        version = ver?;
+    };
 
-    dbg!(&sql);
+    match version.is_empty() {
+        true => Err(Box::new(Error::new(ErrorKind::NotFound, "MOD_NOT_FOUND"))),
+        false => Ok(version),
+    }
+}
 
-    let mut versionmaps: Vec<DBModlistVersions> = Vec::new();
-    //TODO catch sql errors better
-    let mut cursor = connection.prepare(sql).unwrap().into_cursor();
+pub fn userlist_get_all_current_version_ids(config: Cfg, list_id: String) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+    let data = format!("{}/data.db", config.data);
+    let connection = Connection::open(data)?;
 
-    while let Some(Ok(row)) = cursor.next() {
-        println!("{}: {}", row.get::<String, _>(0), row.get::<String, _>(1));
-        versionmaps.push(DBModlistVersions { mod_id: row.get::<String, _>(0), versions: row.get::<String, _>(1) })
+    let mut versions: Vec<String> = Vec::new();
+    let mut stmt = connection.prepare(format!("SELECT current_version FROM {}", list_id).as_str())?;
+    let id_iter = stmt.query_map([], |row| {
+        row.get::<usize, String>(0)
+    })?;
+
+    for id in id_iter {
+        versions.push(id?);
     };
 
-    if versionmaps.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_MODS_ON_LIST"))); };
+    if versions.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_MODS_ON_LIST"))); };
 
-    Ok(versionmaps)
-    */
-    Ok(vec![DBModlistVersions { mod_id: String::new(), versions: String::new() }])
+    Ok(versions)
 }
 
-pub fn get_list_version(config: Cfg, list: List, mod_id: String) -> Result<String, Box<dyn std::error::Error>> {
-    /*
+pub fn userlist_change_versions(config: Cfg, list_id: String, current_version: String, versions: String, link: String, mod_id: String) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-    
-    let sql = format!("SELECT applicable_versions FROM {} WHERE mod_id = '{}'", list.id, mod_id);
-
-    //TODO catch sql errors better
-    let mut version: String = String::new();
-    connection.iterate(sql, |ver| {
-        if ver.is_empty() { return false; };
-        for &(_column, value) in ver.iter() {
-            version = String::from(value.unwrap());
-        }
-        true
-    }).unwrap();
-    
-    if version.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_MODS_ON_LIST"))); };
+    let connection = Connection::open(data)?;
 
-    Ok(version)
-    */
-    Ok(String::new())
+    connection.execute(format!("UPDATE {} SET current_version = ?1, applicable_versions = ?2, current_download = ?3 WHERE mod_id = ?4", list_id).as_str(), [current_version, versions, link, mod_id])?;
+    Ok(())
 }
 
+pub fn userlist_get_all_downloads(config: Cfg, list_id: String) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+    let data = format!("{}/data.db", config.data);
+    let connection = Connection::open(data).unwrap();
+
+    let mut links: Vec<String> = Vec::new();
+    let mut stmt = connection.prepare(format!("SELECT current_download FROM {}", list_id).as_str())?;
+    let link_iter = stmt.query_map([], |row| {
+        row.get::<usize, String>(0)
+    })?;
+
+    for link in link_iter {
+        let l = link?;
+        println!("Found link {}", String::from(&l));
+        links.push(l)
+    };
+
+    if links.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_MODS_ON_LIST"))); };
+
+    Ok(links)
+}
 
 //lists
 pub fn lists_insert(config: Cfg, id: String, mc_version: String, mod_loader: Modloader) -> Result<(), Box<dyn std::error::Error>> {
@@ -196,222 +238,134 @@ pub fn lists_insert(config: Cfg, id: String, mc_version: String, mod_loader: Mod
     Ok(())
 }
 
-pub fn remove_list(config: Cfg, id: String) -> Result<(), Box<dyn std::error::Error>> {
-    /*
+pub fn lists_remove(config: Cfg, id: String) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql_list = format!("DELETE FROM lists WHERE id = '{}'", id);
-    let sql_table = format!("DROP TABLE '{}'", id);
-    let sql = format!("{};{};", sql_list, sql_table);
+    let connection = Connection::open(data)?;
 
-    connection.execute(sql)
-    */
+    connection.execute("DELETE FROM lists WHERE id = ?", [&id])?;
+    connection.execute(format!("DROP TABLE {}", id).as_str(), [])?;
     Ok(())
 }
 
-pub fn get_lists(config: Cfg) -> Result<Vec<String>, Box<dyn std::error::Error>> {
-    /*
+pub fn lists_get(config: Cfg, list_id: String) -> Result<List, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = "SELECT id FROM lists";
-    
-    let mut list: Vec<String> = Vec::new();
-    //TODO catch sql errors better
-    connection.iterate(sql, |ids| {
-        if ids.is_empty() { return false; };
-        for &(_column, value) in ids.iter() {
-            list.push(String::from(value.unwrap()));
-        }
-        true
-    }).unwrap();
-    match list.is_empty() {
-        true => Err(Box::new(std::io::Error::new(ErrorKind::NotFound, "NO_LISTS"))),
-        false => Ok(list),
-    }
-    */
-    Ok(vec![String::new()])
-}
-
-pub fn get_current_versions(config: Cfg, list: List) -> Result<Vec<String>, Box<std::io::Error>> {
-    /*
-    let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = format!("SELECT current_version FROM {}", list.id);
+    let connection = Connection::open(data).unwrap();
 
-    dbg!(&sql);
+    let mut list = List { id: String::new(), mc_version: String::new(), modloader: Modloader::Fabric };
+    let mut stmt = connection.prepare("SELECT mc_version, modloader FROM lists WHERE id = ?")?;
 
-    let mut versions: Vec<String> = Vec::new();
-    //TODO catch sql errors better
-    let mut cursor = connection.prepare(sql).unwrap().into_cursor();
+    let list_iter = stmt.query_map([&list_id], |row| {
+        Ok(vec![row.get::<usize, String>(0)?, row.get::<usize, String>(1)?])
+    })?;
 
-    while let Some(Ok(row)) = cursor.next() {
-        versions.push(row.get::<String, _>(0));
+    for l in list_iter {
+        let li = l?;
+        list = List { id: String::from(&list_id), mc_version: String::from(&li[0]), modloader: get_modloader(String::from(&li[1]))? };
     };
 
-    if versions.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_MODS_ON_LIST"))); };
-
-    Ok(versions)
-    */
-    Ok(vec![String::new()])
-}
-
-pub fn get_list(config: Cfg, id: String) -> Result<List, Box<dyn std::error::Error>> {
-    /*
-    let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = format!("SELECT mc_version, modloader FROM lists WHERE id = '{}'", id);
+    if list.id.is_empty() { return Err(Box::new(Error::new(ErrorKind::Other, "LIST_NOT_FOUND"))); }
     
-    let mut list = vec![];
-    //TODO catch sql errors better
-    connection.iterate(sql, |ids| {
-        if ids.is_empty() { return false; };
-        for &(_column, value) in ids.iter() {
-            list.push(String::from(value.unwrap()));
-        }
-        true
-    }).unwrap();
-
-    if list.len() != 2 { return Err(Box::new(std::io::Error::new(ErrorKind::InvalidData, "LIST_MISSING_DATA"))) };
-    
-    Ok(List { id, mc_version: String::from(&list[0]), modloader: get_modloader(String::from(&list[1]))? })
-    */
-    Ok(List { id: String::new(), mc_version: String::new(), modloader: Modloader::Fabric })
+    Ok(list)
 }
 
-pub fn change_list_versions(config: Cfg, list: List, current_version: String, versions: Vec<String>, mod_id: String) -> Result<(), Box<dyn std::error::Error>> {
-    /*
+pub fn lists_get_all_ids(config: Cfg) -> Result<Vec<String>, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
+    let connection = Connection::open(data).unwrap();
+    
+    let mut list_ids: Vec<String> = Vec::new();
+    let mut stmt = connection.prepare("SELECT id FROM lists")?;
+    let id_iter = stmt.query_map([], |row| {
+        row.get::<usize, String>(0)
+    })?;
 
-    let sql = format!("UPDATE {} SET current_version = '{}', applicable_versions = '{}' WHERE mod_id = '{}'", list.id, current_version, versions.join("|"), mod_id);
+    for id in id_iter {
+        println!("Found id {:?}", id.as_ref().unwrap());
+        list_ids.push(id?)
+    };
 
-    connection.execute(sql)
-    */
-    Ok(())
+    match list_ids.is_empty() {
+        true => Err(Box::new(std::io::Error::new(ErrorKind::NotFound, "NO_LISTS"))),
+        false => Ok(list_ids),
+    }
 }
 
-//DOWNLOAD
-
-pub fn insert_dl_link(config: Cfg, list: List, mod_id: String, link: String) -> Result<(), Box<dyn std::error::Error>> {
-    /*
+//config
+pub fn config_change_current_list(config: Cfg, id: String) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = format!("UPDATE {} SET current_download = '{}' WHERE mod_id = '{}'", list.id, link, mod_id);
+    let connection = Connection::open(data)?;
 
-    connection.execute(sql)
-    */
+    connection.execute("UPDATE user_config SET value = ? WHERE id = 'current_list'", [id])?;
     Ok(())
 }
 
-pub fn get_dl_links(config: Cfg, list: List) -> Result<Vec<String>, Box<std::io::Error>> {
-    /*
+pub fn config_get_current_list(config: Cfg) -> Result<String, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = format!("SELECT current_download FROM {}", list.id);
-
-    dbg!(&sql);
-
-    let mut links: Vec<String> = Vec::new();
-    //TODO catch sql errors better
-    let mut cursor = connection.prepare(sql).unwrap().into_cursor();
+    let connection = Connection::open(data).unwrap();
+    
+    let mut list_id = String::new();
+    let mut stmt = connection.prepare("SELECT value FROM user_config WHERE id = 'current_list'")?;
+    let list_iter = stmt.query_map([], |row| {
+        row.get::<usize, String>(0)
+    })?;
 
-    while let Some(Ok(row)) = cursor.next() {
-        links.push(row.get::<String, _>(0));
+    for list in list_iter {
+        list_id = list?;
     };
 
-    if links.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_MODS_ON_LIST"))); };
-
-    Ok(links)
-    */
-    Ok(vec![String::new()])
+    if list_id.is_empty() { return Err(Box::new(Error::new(ErrorKind::Other, "NO_CURRENT_LIST"))); }
+    
+    Ok(list_id)
 }
 
-//config
-pub fn change_list(config: Cfg, id: String) -> Result<(), Box<dyn std::error::Error>> {
-    /*
+//SETUP(UPDATES)
+pub fn s_userlist_update_download(config: Cfg, list_id: String, mod_id: String, link: String) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = format!("UPDATE user_config SET value = '{}' WHERE id = 'current_list'", id);
+    let connection = Connection::open(data)?;
 
-    connection.execute(sql)
-    */
+    connection.execute(format!("UPDATE {} SET current_download = ?1 WHERE mod_id = ?2", list_id).as_str(), [link, mod_id])?;
     Ok(())
 }
 
-pub fn get_current_list_id(config: Cfg) -> Result<String, Box<dyn std::error::Error>> {
-    /*
+pub fn s_config_create_version(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
+    let connection = Connection::open(data)?;
 
-    let sql = "SELECT id FROM lists";
-    
-    let mut list: String = String::new();
-    //TODO catch sql errors better
-    connection.iterate(sql, |ids| {
-        if ids.is_empty() { return false; };
-        for &(_column, value) in ids.iter() {
-            list = String::from(value.unwrap());
-        }
-        true
-    }).unwrap();
-    if list.is_empty() {
-        get_lists(config)?;
-        panic!("current list field should never be empty if there are other lists");
-    };
-    Ok(list)
-    */
-    Ok(String::new())
+    connection.execute("INSERT INTO 'user_config' VALUES ( 'db_version', '0.2' )", ())?;
+    Ok(())
 }
 
-pub fn update_dbversion(config: Cfg, ver: String) -> Result<(), Box<dyn std::error::Error>> {
-    /*
+pub fn s_config_update_version(config: Cfg, ver: String) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let sql = format!("UPDATE user_config SET value = '{}' WHERE id = 'db_version'", ver);
+    let connection = Connection::open(data)?;
 
-    connection.execute(sql)
-    */
+    connection.execute("UPDATE user_config SET value = ? WHERE id = 'db_version'", [ver])?;
     Ok(())
 }
 
-pub fn create_dbversion(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
-    /*
+pub fn s_config_get_version(config: Cfg) -> Result<String, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-    let sql = "INSERT INTO 'user_config' VALUES ( 'db_version', '0.2' );";
-    connection.execute(sql)
-    */
-    Ok(())
+    let connection = Connection::open(data)?;
+    
+    let mut version: String = String::new();
+    let mut stmt = connection.prepare("SELECT value FROM user_config WHERE id = 'db_version'")?;
+    let ver_iter = stmt.query_map([], |row| {
+        row.get::<usize, String>(0)
+    })?;
+
+    for ver in ver_iter {
+        version = ver?;
+    };
+
+    if version.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_DBVERSION"))); };
+    Ok(version)
 }
 
-pub fn user_dbversion(config: Cfg) -> Result<String, Box<dyn std::error::Error>> {
-    /*
+pub fn s_insert_column(config: Cfg, table: String, column: String, c_type: String) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
+    let connection = Connection::open(data)?;
 
-    let sql = "SELECT db_version FROM user_config";
-    
-    let mut ver: String = String::new();
-    //TODO catch sql errors better
-    connection.iterate(sql, |ids| {
-        if ids.is_empty() { return false; };
-        for &(_column, value) in ids.iter() {
-            ver = String::from(value.unwrap());
-        }
-        true
-    })?;
-    if ver.is_empty() { return Err(Box::new(std::io::Error::new(ErrorKind::Other, "NO_DBVERSION"))); };
-    Ok(ver)
-    */
-    Ok(String::from("0.2"))
+    connection.execute(format!("ALTER TABLE {} ADD '{}' {}", table, column, c_type).as_str(), ())?;
+    Ok(())
 }
 
 pub fn db_setup(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
@@ -432,21 +386,3 @@ pub fn db_setup(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-pub fn insert_column(config: Cfg, table: String, column: String, c_type: String) -> Result<(), Box<dyn std::error::Error>> {
-    /*
-    let data = format!("{}/data.db", config.data);
-    let connection = sqlite::open(data).unwrap();
-
-    let ct = match c_type {
-        sqlite::Type::Null => "NULL",
-        sqlite::Type::Float => "FLOAT",
-        sqlite::Type::Binary => "BINARY",
-        sqlite::Type::String => "TEXT",
-        sqlite::Type::Integer => "INT",
-    };
-
-    let sql = format!("ALTER TABLE {} ADD '{}' {}", table, column, ct);
-    connection.execute(sql)
-    */
-    Ok(())
-}
diff --git a/src/lib.rs b/src/lib.rs
index e059293..1e7ebbf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,7 +9,7 @@ use std::io::{Error, ErrorKind};
 pub use apis::*;
 pub use commands::*;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Modloader {
     Fabric,
     Forge