mps/src/storage.rs

use base64::prelude::*;

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)
});
static PASSWORD_TEST_SALT: &str = "MyPasswordStorage1234567890";


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)
    }
}

struct Encoder {
    passphrase: String
}

impl Encoder {
    pub fn from(passphrase: String) -> Encoder {
        Encoder { passphrase }
    }

    // TODO: get by ref
    pub fn encode(&self, line: String) -> String {
        // TODO: use passphrasee to encode
        BASE64_STANDARD.encode(line)
    }

    // TODO: review error type
    pub fn decode(&self, line: String) -> io::Result<String> {
        let content = BASE64_STANDARD.decode(line).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
        match String::from_utf8(content) {
            Ok(s) => Ok(s),
            Err(e) => Err(io::Error::new(io::ErrorKind::InvalidData, e))
        }
    }
    pub fn get_encoded_test_passphrase(&self) -> String {
        // TODO: encode SALT const with passphrase
        self.passphrase.clone()
    }
}

pub struct Storage {
    pub 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> {
        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"
                    )),
        };
        for line in lines {
            match line {
                Ok(line) => {
                    if id.is_none() {
                        id = Some(line);
                    } else {
                        let content = encoder.decode(line)?;
                        items.insert(Item::from(id.unwrap(), content));
                        id = None;
                    }
                },
                Err(e) => {
                    eprintln!("Error reading line, {}", e);
                }
            }
        }
        Ok(Storage {
            items: items,
            encoder: 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 {
        let path = Path::new(&*STORAGE_FOLDER);
        return path.exists();
    }

    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 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.encode(item.content.clone());
            writeln!(file, "{}", content)?;
        }
        Ok(())
    }
}