extern crate base64;

use base64::{encode, decode};
use std::collections::HashMap;
use std::fs::File;
use std::{fs, io};
use std::io::prelude::*;
use std::path::Path;

pub static STORE_DIR: &str = "./simplestore";

pub trait F {
    fn get(&self, table: &str, id: &str) -> Result<String, String>;
    fn put(&self, table: &str, id: &str, data: String) -> bool;
    fn fetch(&self, table: &str) -> Result<HashMap<String, String>, String>;
}

pub struct Store {
   pub store_dir: &'static str,
}

impl Store {
    pub fn new() -> Store {
        Store {
            store_dir: STORE_DIR,
        }
    }

    pub fn ssd(&mut self, s: &'static str) {
        self.store_dir = s;
    }

    fn calc_id(&self, table: &str, id: &str) -> String {
        String::from(format!("{}/{}/{}", STORE_DIR, table, id))
    }

    fn calc_table(&self, table: &str) -> String {
        String::from(format!("{}/{}", STORE_DIR, table))
    }

    fn is_table_exists(&self, table: &str) -> bool {
        Path::new(&self.calc_table(table)).exists()
    }

    fn is_id_exists(&self, table: &str, id: &str) -> bool {
        Path::new(&self.calc_id(table, id)).exists()
    }

    fn create_resource(&self, table: &str) {
        if !self.is_table_exists(table) {
            fs::create_dir(self.calc_table(table)).unwrap();
        }
    }
}

impl F for Store {
    fn get(&self, table: &str, id: &str) -> Result<String, String> {
        if !self.is_id_exists(table, id) {
            return Err(String::from("id not found"))
        }

        let filename = self.calc_id(table, id);
        let mut data = String::new();
        let mut f = File::open(filename).expect("Unable to open file");
        f.read_to_string(&mut data).expect("Unable to read string");
    
        let decoded = decode(data).unwrap();

        Ok(decoded.iter().map(|&c| c as char).collect::<String>())
    }

    fn put(&self, table: &str, id: &str, data: String) -> bool {
        self.create_resource(table);
        let f = self.calc_id(table, id);

        let encoded = encode(data);
        fs::write(f, encoded).expect("Unable to write file");
        return true;
    }

    fn fetch(&self, table: &str,) -> Result<HashMap<String, String>, String> {
        self.create_resource(table);
        let mut map = HashMap::<String, String>::new();
        let d = self.calc_table(table);

        let mut entries = fs::read_dir(d).unwrap()
        .map(|res| res.map(|e| e.path()))
        .collect::<Result<Vec<_>, io::Error>>().unwrap();
       
        for entry in entries {
            match entry.to_str() {
                Some(filename) => {
                    let mut data = String::new();
                    let mut f = File::open(String::from(filename)).expect("Unable to open file");
                    f.read_to_string(&mut data).expect("Unable to read string");
                
                    let decoded = decode(data).unwrap();

                    map.insert(String::from(split_last(filename)), decoded.iter().map(|&c| c as char).collect::<String>());
                },
                None => println!("err"),
            }
        }

        Ok(map)
    }
}

fn split_last(path: &str) -> &str {
    let chunks: Vec<&str> = path.split("/").collect();

    chunks.last().unwrap()
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::{Instant};

    #[test]
    fn test_calc_file() {
        let s = Store::new();

        let n = s.calc_id("asd", "asd");
        let expected = String::from("/opt/simplestore/asd/asd");
        if expected != n {
            panic!("string mismatch")
        }
    }

    #[test]
    fn test_put() {
        let s = Store::new();

        let start = Instant::now();
        s.put("user", "12345", String::from("Feri"));

        let duration = start.elapsed();

        println!("Time elapsed in s.put() is: {:?}", duration);
    
        let start = Instant::now();
        match s.get("user", "12345") {
            Ok(data) => println!("{}", data),
            Err(err) => println!("{}", err),
        }
        let duration = start.elapsed();
        println!("Time elapsed in s.get() is: {:?}", duration);
    }

    #[test]
    fn test_fetch() {
        let s = Store::new();

        let start = Instant::now();
        s.put("user", "12345", String::from("Feri"));
        s.put("user", "12346", String::from("Feri"));
        s.put("user", "12347", String::from("Feri"));
        s.put("user", "12348", String::from("Feri"));
        s.put("user", "12349", String::from("Feri"));

        let duration = start.elapsed();

        println!("Time elapsed in s.put() is: {:?}", duration);
    
        let start = Instant::now();
        match s.fetch("user") {
            Ok(data) => println!("{:?}", data),
            Err(_) => println!("err")

        }
        let duration = start.elapsed();
        println!("Time elapsed in s.fetch() is: {:?}", duration);
    }
}