use std::io::BufReader;
use std::fs::File;
use std::io::prelude::*;

use rand::rngs::OsRng;
use ed25519_dalek::SigningKey;
use ed25519_dalek::Signature;
use ed25519_dalek::Signer;

fn main() ->  std::io::Result<()>{
    let action = std::env::args().nth(1).expect("no command given");
    if action == "sign" {
        let keyfilepath = std::env::args().nth(2).expect("no keyfilepath given");
        let messagefilepath = std::env::args().nth(3).expect("no message given");
        let maybe_signature_filepath = std::env::args().nth(4);


        let mut keyfile = File::open(&keyfilepath).expect("no file found");
        let mut keybuffer: [u8; 32] = [0; 32];
        keyfile.read(&mut keybuffer).expect("buffer overflow");
        let signing_key: SigningKey = SigningKey::from_bytes(&keybuffer);

        let messagefile= File::open(&messagefilepath).expect("no file found");
        let mut messagereader = BufReader::new(messagefile);
        let mut messagebuf = Vec::new();
        messagereader.read_to_end(&mut messagebuf)?;



        println!("Using key {keyfilepath}");

        let signature: Signature = signing_key.sign(&messagebuf);
        if maybe_signature_filepath.is_some() {
            let filename = maybe_signature_filepath.expect("Not possible");
            let mut file = File::create(filename.clone())?;
            println!("Writing signature to {filename}");
            file.write_all(&signature.to_bytes())?;
        } else {
            println!("Signture: {signature}");
        }
        return Ok(())
    } else if action == "create" {
        let keyfilepath = std::env::args().nth(2).expect("no keyfilepath given");
        let mut csprng = OsRng;
        let signing_key: SigningKey = SigningKey::generate(&mut csprng);

        println!("Writing new key to {keyfilepath}");
        let mut file = File::create(keyfilepath)?;
        file.write_all(&signing_key.to_bytes())?;
        return Ok(());
    } else {
        println!("Unrecognized command {action}");
        return Ok(());
    }
}