pub fn add(left: usize, right: usize) -> usize {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
    #[test]
    fn test_update_secret() {
        let db: sled::Db = sled::open("sled_db").unwrap();
        update_secret(&db, "foo", TempSecret{version: -99, content: "cool".to_string()}); 
    }
    #[test]
    fn test_get_secret() {
        let db: sled::Db = sled::open("sled_db").unwrap();
        get_secret(&db, "foo"); 
    }
}

use sled::Db;
use base::{deserialize_secret_struct, serialize_secret_json, TempSecret};

/// [TODO] Currently no proper versioning 
/// inserts a secret. If there was already a secret in the given path, the version is incremented
fn update_secret(db: &Db, path: &str, mut secret: TempSecret) {
    match get_secret(db, path) {
        Some(old_secret) => {
            // case secret found. TODO save it somewhere for versioning
            secret.version = old_secret.version + 1;
            #[cfg(test)]
            print!("something was found. new version {} \n", secret.version) 
        }
        None => {
            // case new secret
            secret.version = 1;
        }
    }
    // if let secret_json = serialize_secret_json(&secret) {
    // let _res = db.insert(path, secret_json); // maybe this can be handled cleaner
    match serialize_secret_json(&secret) {
        Ok(secret_json) => {
            #[cfg(test)]
            println!("String: {:?}", secret_json.clone());
            let as_ivec = sled::IVec::from(secret_json.into_bytes()); // maybe outsource this in a fn later
            #[cfg(test)]
            println!("ivec: {:?}", as_ivec);
            match db.insert(path, as_ivec) {
                Ok(_) => println!("Secret inserted"),
                Err(e) => eprintln!("Failed to insert secret: {}", e),
            }
        }
        Err(e) => eprintln!("Failed to serialize secret: {}", e),
    }
}

// read and return a secret from the DB
//if there is no secret, return None
fn get_secret(db: &Db, path: &str) -> Option<TempSecret>{
    let raw_secret;
    match db.get(path) {
        Ok(Some(ivec)) => {
            raw_secret = ivec;
        }
        Err(e) => {
            eprintln!("Error on retrieving secret: {}", e);
            return None;
        }
        Ok(None) => {
            return None;
        }
    }
     // outsource this in a fn later. TODO maybe deal with unwrap
    let as_str = String::from_utf8(raw_secret.to_vec()).unwrap();
    match deserialize_secret_struct(&as_str) {
        Ok(secret) => {
            #[cfg(test)]
            println!("got some secret: {:?}", secret);
            return Some(secret);
        }
        Err(e) => {
            eprintln!("error on secret deserialization: {}", e);
            return None;
        }

    } 
}