use gulkana;
use rand::prelude::*;
use serde::{Serialize}; 

pub enum FSError{
    KeyAllreadyPresent,
    KeyNotFound,
    NodeNotLink,
    NodeNotData,
    PathNotPresent,
    FileError,
    SerializeError,
}
impl FSError{
    #[allow(dead_code)]
    fn to_string(self)->String{
        match self{
            FSError::KeyAllreadyPresent=>"KeyAllreadyPresent".to_string(),
            FSError::KeyNotFound=>"KeyNotFound".to_string(),
            FSError::NodeNotLink=>"NodeNotLink".to_string(),
            FSError::NodeNotData=>"NodeNotData".to_string(),
            FSError::PathNotPresent=>"PathNotPresent".to_string(),
            FSError::FileError=>"File Error".to_string(),
            FSError::SerializeError=>"Error when Serializing to String".to_string(),
        }
    }
}

impl From<gulkana::DBOperationError> for FSError{
    fn from(error:gulkana::DBOperationError)->Self{
        match error{
            gulkana::DBOperationError::KeyAllreadyPresent
                =>FSError::KeyAllreadyPresent,
            gulkana::DBOperationError::KeyNotFound
                =>FSError::KeyNotFound,
            gulkana::DBOperationError::NodeNotLink
                =>FSError::NodeNotLink,
            gulkana::DBOperationError::NodeNotData
                =>FSError::NodeNotData,
            gulkana::DBOperationError::SerializeError
                =>FSError::SerializeError,
            gulkana::DBOperationError::FSError
                =>FSError::FileError,

        }
    }
}
impl From<std::io::Error> for FSError{

    fn from(error: std::io::Error)->Self{
        match error{
            _ =>FSError::FileError,
        }
    }
}

impl From<gulkana::SerializeError> for FSError{

    fn from(error: gulkana::SerializeError)->Self{
        match error{
            _ =>FSError::SerializeError,
        }
    }
}

pub struct Database<DataType:std::clone::Clone+Serialize,LinkLabel:std::clone::Clone+Serialize>{
    //root file system has key of 0
    db:gulkana::DataStructure<u32,DataType,LinkLabel>,
   // rng:ThreadRng,
}
pub struct ChildIter<'a,DataType:std::clone::Clone+Serialize,
    LinkLabel:std::clone::Clone+Serialize>{
    db:&'a Database<DataType,LinkLabel>,
    iter:std::slice::Iter<'a,KeyType>
}
impl<'a,DataType:std::clone::Clone+Serialize,LinkLabel:std::clone::Clone+Serialize>
    Iterator for ChildIter<'a,DataType,LinkLabel>{
    type Item = (& 'a KeyType,DataType);
    fn next(&mut self)->Option<Self::Item>{
        let index = self.iter.next()?;
        let res = self.db.get(index);
        if res.is_ok(){
            return Some((index,res.ok().unwrap()));
        }else{
            return None;
        }
    }
}
type KeyType=u32;
impl<DataType:std::clone::Clone+Serialize,LinkLabel:std::clone::Clone+Serialize>
    Database<DataType,LinkLabel>{
    pub fn insert(&mut self,input: DataType,parent:KeyType)->Result<KeyType,FSError>{
        let mut rng = thread_rng();
        let temp_key:KeyType = rng.gen();
        //checking if parent exists
        if self.db.contains(&parent){
            self.db.insert(&temp_key,input)?;
            self.db.append_links(&parent,&temp_key)?;
            return Ok(temp_key);
        }else{
            return Err(FSError::KeyNotFound);
        }
    }
    pub fn get(&self,key:&KeyType)->Result<DataType,FSError>{
        let h = self.db.get(key)?;
        return Ok(h.clone());

    }
    pub fn make_dir(&mut self,label:LinkLabel)->Result<KeyType,FSError>{
        let mut rng = thread_rng();
        let temp_key = rng.gen();
        self.db.insert_link(&temp_key,&vec![],label)?;
        return Ok(temp_key);

    }
    fn make_dir_key(&mut self,key:&KeyType,label:LinkLabel)->Result<(),FSError>{
        let res = self.get(key);
        //if key is not present
        if res.is_err(){
            self.db.insert_link(key,&vec![],label)?;
            return Ok(());
        }else{

            return Err(FSError::KeyAllreadyPresent);
        }
    }
    pub fn get_node_children(&self,key:KeyType)->Result<&Vec<KeyType>,FSError>{
        let link = self.db.get_links(&key)?;
        return Ok(link);

    }
    pub fn iter_children(&self,key:&KeyType)->Result<ChildIter<DataType,LinkLabel>,FSError>{
        Ok(ChildIter{
            db:self,
            iter:self.db.get_links(key)?.iter()
        })
    }
}
pub fn new<DataType:std::clone::Clone+Serialize,LinkLabel:std::clone::Clone+Serialize>
    (backing:Option<String>,dir_label:LinkLabel)->Result<Database<DataType,LinkLabel>,FSError>{
    let mut db = Database{
        db:gulkana::new_datastructure(backing),
    };
    
    db.make_dir_key(&0,dir_label)?;
    return Ok(db);
}

#[cfg(test)]
mod tests{
    use super::*;
    #[derive(Clone,Serialize)]
    enum DB{
        Directory,
    }
    #[derive(Clone,Serialize,PartialEq)]
    struct DBEnt{
        f:u32,
    }
    #[test]
    #[allow(unused_must_use)]
    fn insert(){
        let in_db = DBEnt{
            f:1,
        };
        let mut db = new(None,DB::Directory).ok().unwrap();
        let key_res = db.insert(in_db.clone(),0).ok().unwrap();
        let out = db.get(&key_res);
        assert!(in_db==out.ok().unwrap());
    }
    #[test]
    fn get_root_children(){
        let mut db = new(None,DB::Directory).ok().unwrap();
        let in_db = DBEnt{
            f:0,
        };
        let key = db.insert(in_db.clone(),0).ok().unwrap();
        let dir = db.make_dir(DB::Directory).ok().unwrap();
        let key2 = db.insert(in_db,dir).ok().unwrap();
        let v = db.get_node_children(0).ok().unwrap(); 
        for i in v{
            assert!(i==&key);
        }
        let v2 = db.get_node_children(dir).ok().unwrap();
        for i in v2{
            assert!(i==&key2);
        }
    
    }
    #[test]
    fn iterate_root(){
        let mut db = new(None,DB::Directory).ok().unwrap();
        let key = db.insert(DBEnt{f:0},0).ok().unwrap();
        for (key_t,data) in db.iter_children(&0).ok().unwrap(){
            assert!(key_t==&key&&data.f==0);
        }
        
    }
    #[test]
    fn mass_insert(){
        let in_db = DBEnt{
            f:3,
        };
        let mut db = new(None,DB::Directory).ok().unwrap();
        for _i in 1..10000{
            let key_res = db.insert(in_db.clone(),0);
            assert!(key_res.is_ok());
        }

    }
}