mps/src/storage.rs

use crate::encoder;

use encoder::Encoder;

use once_cell::sync::Lazy;

use std::collections::HashSet;
use std::hash::{Hash, Hasher};

use std::fs;
use std::path::Path;
use std::io::{self, Write, BufRead};
use std::fmt;
use std::cmp::{PartialEq, Ordering};


static STORAGE_FOLDER: Lazy<String> = Lazy::new(|| "storage".to_string() );
static STORAGE_PATH: Lazy<String> = Lazy::new(|| { 
    format!("{}/db.mps", &*STORAGE_FOLDER)
});


#[derive(Clone)]
pub struct Item {
    pub id: String,
    pub content: String
}

impl Item {
    pub fn from(s: String, c: String) -> Item {
        Item { id: s, content: c }
    }
    // used only to search in HashSet
    pub fn from_empty(s: String) -> Item {
        Item { id: s, content: String::from("") }
    }
}

impl PartialEq for Item {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id 
    }
}

impl Eq for Item {}

impl Hash for Item {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

impl fmt::Display for Item {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        writeln!(f, "{}", self.id)?;
        writeln!(f, "---------")?;
        writeln!(f, "{}", self.content)
    }
}

impl PartialOrd for Item {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.id.partial_cmp(&other.id)
    }
}

impl Ord for Item {
    fn cmp(&self, other: &Self) -> Ordering {
        self.id.cmp(&other.id)
    }
}

pub struct Storage {
    items: HashSet::<Item>,
    encoder: Encoder
}

impl Storage {
    pub fn new(passphrase: String) -> Storage {
        Storage {
            items: HashSet::<Item>::new(),
            encoder: Encoder::from(&passphrase)
        }
    }
    pub fn from_db(passphrase: String) -> io::Result<Storage> {
        if !Storage::is_inited() {
            return Err(io::Error::new(
                io::ErrorKind::Other,
                "Storage is not initialized"
            ));
        }
        let encoder = Encoder::from(&passphrase);
        // TODO: throw error is password is incorrect
        let file = fs::File::open(&*STORAGE_PATH)?;
        let reader = io::BufReader::new(file);
        let mut items = HashSet::<Item>::new();
        let mut id: Option<String> = None;
        let mut lines = reader.lines();
        // TODO: uncomment when innit saving implemented
        let passtest = match lines.next() {
            Some(line) => line?,
            None => return Err(
                        io::Error::new(io::ErrorKind::InvalidData,
                        "Bad storage db format: no passphrase in the beginnning"
                    )),
        };
        if !encoder.test_encoded_passphrase(passtest)? {
            return Err(io::Error::new(io::ErrorKind::InvalidData, "Wrong passphrase"));
        }
        for line in lines {
            match line {
                Ok(line) => {
                    if id.is_none() {
                        id = Some(line);
                    } else {
                        let content = encoder.decrypt(line)?;
                        items.insert(Item::from(id.unwrap(), content));
                        id = None;
                    }
                },
                Err(e) => {
                    eprintln!("Error reading line, {}", e);
                }
            }
        }
        Ok(Storage {
            items,
            encoder
        })
    }

    pub fn init(passphrase: String) -> io::Result<()> {
        fs::create_dir(&*STORAGE_FOLDER)?;
        println!("Storage folder created");
        //let mut db = DB::init(&*STORAGE_PATH, pass)?;

        fs::File::create(&*STORAGE_PATH)?;
        println!("Storage db created.");
        let st = Storage::new(passphrase);
        st.dump()?;
        
        println!("Initialization complete.");
        println!("");
        println!("Now it's required to add folder `{}` under git manually.", &*STORAGE_FOLDER);
        println!("Don't worry it's going to be encrypted.");
        Ok(())
    }

    pub fn print_init_hint() {
        println!("mps can work only when storage inited.");
        println!("Hint: you can restore your storage if you have it already:");
        println!("  git clone <your_storage_git_url> {}", &*STORAGE_FOLDER);
        println!("to init manually your storage and config")
    }

    pub fn is_inited() -> bool {
        // TODO: check db
        // TODO check git
        let path = Path::new(&*STORAGE_FOLDER);
        return path.exists();
        
    }
    
    pub fn ids(&self) -> Vec<String> {
        let mut result = Vec::new();
        for item in self.items.iter() {
            result.push(item.id.clone());
        }
        result.sort();
        result
    }

    pub fn contains(&self, id: &String) -> bool {
        let item = Item::from_empty(id.clone());
        self.items.contains(&item)
    }

    pub fn get(&self, id: &String) -> &Item {
        let item = Item::from_empty(id.clone());
        self.items.get(&item).unwrap()
    }

    pub fn add(&mut self, item: Item) {
        self.items.insert(item);
    }

    pub fn update(&mut self, item: Item) {
        self.items.remove(&item);
        self.items.insert(item);
    }

    pub fn dump(&self) -> io::Result<()> {
        let mut file = fs::OpenOptions::new()
            .write(true)
            .append(false)
            .open(&*STORAGE_PATH)?;
        writeln!(file, "{}", self.encoder.get_encoded_test_passphrase())?;

        for item in self.items.iter() {
            writeln!(file, "{}", item.id)?;
            let content = self.encoder.encrypt(&item.content);
            writeln!(file, "{}", content)?;
        }
        Ok(())
    }
}