use std::{
    fs::File,
    io::Write,
    path::{Path, PathBuf},
};

use pem::Pem;

use bft_json_crdt::keypair::{make_keypair, KeyPair};

const KEY_FILE: &str = "keys.pem";
const CONFIG_FILE: &str = "config.toml";

pub(crate) fn init(home: PathBuf) -> Result<(), std::io::Error> {
    ensure_side_directory_exists(&home)?;

    let (key_path, config_path) = side_path(home.clone());

    let pem = create_pem();
    write_pem(key_path, pem)?;

    let mut file = File::create(config_path)?;

    Ok(())
}

/// Ensures that the directory at side_dir exists, so we have a place
/// to store our key file and config file.
fn ensure_side_directory_exists(side_dir: &PathBuf) -> Result<(), std::io::Error> {
    if side_dir.exists() {
        return Ok(());
    }
    println!("Creating side config directory: {:?}", side_dir);
    std::fs::create_dir_all(side_dir)
}

/// Writes a PEM-encoded string to a file at key_path.
fn write_pem(key_path: PathBuf, pem: String) -> Result<(), std::io::Error> {
    println!("Writing key to: {:?}", key_path);
    let mut file = File::create(key_path)?;
    file.write(pem.to_string().as_bytes())?;
    Ok(())
}

/// Makes an Ed25519 keypair and returns the public and private keys as a PEM-encoded string.
fn create_pem() -> String {
    let keys = make_keypair();

    let public_pem = Pem::new("PUBLIC", keys.public().to_string());
    let private_pem = Pem::new("PRIVATE", keys.private().to_string());
    pem::encode_many(&[public_pem, private_pem])
}

/// Returns the path to the key file for this host OS.
fn side_path(prefix: PathBuf) -> (PathBuf, PathBuf) {
    let mut key_path = prefix.clone();
    key_path.push(KEY_FILE);

    let mut config_path = prefix.clone();
    config_path.push(CONFIG_FILE);

    (key_path, config_path)
}

#[cfg(test)]
mod tests {
    use std::fs;

    use super::*;

    #[test]
    fn creates_side_node_directory() {
        let mut test_home = PathBuf::new();
        let side_dir = "/tmp/side";

        // clean up any previous test runs
        fs::remove_dir_all(side_dir).expect("couldn't remove side directory during test");

        test_home.push(side_dir);
        let node_dir = Path::new(&test_home).parent().unwrap().to_str().unwrap();
        let _ = init(test_home.clone());
        assert!(std::path::Path::new(node_dir).exists());
    }

    #[test]
    fn creates_key_file() {
        let mut file_path = PathBuf::new();
        file_path.push("/tmp/side");
        let side_dir = file_path.clone();
        file_path.push(KEY_FILE);

        let _ = init(side_dir.clone());
        assert!(file_path.exists());

        // check that the pem is readable
        let pem = fs::read_to_string(file_path).unwrap();
        assert!(pem.contains("PUBLIC"));
        assert!(pem.contains("PRIVATE"));

        assert!(pem::parse_many(&pem).is_ok());
    }

    #[test]
    fn creates_config_file() {
        let mut file_path = PathBuf::new();
        file_path.push("/tmp/side");
        let side_dir = file_path.clone();
        file_path.push(CONFIG_FILE);

        let _ = init(side_dir.clone());
        assert!(file_path.exists());
    }
}