fs-encrypt 0.1.3

use rpassword::read_password;

const USAGE_ERR: &str = "usage: encrypt [encrypt | decrypt] [input_path] [output_path]";

#[derive(PartialEq)]
pub enum CodecType {
    Encrypt,
    Decrypt,
}

pub struct Args {
    pub codec_type: CodecType,
    pub input_path: String,
    pub output_path: String,
    pub password: String,
}

impl Args {
    pub fn arguments(iter: impl Iterator<Item = String>) -> Result<Args, &'static str> {
        let parsed = Self::parse_args(iter);

        match parsed {
            Some(args) => Ok(args),
            None => Err(USAGE_ERR),
        }
    }

    fn parse_args(mut args: impl Iterator<Item = String>) -> Option<Args> {
        args.next();

        let raw_codec = args.next()?;
        let codec_type = Self::parse_codec(&raw_codec)?;

        let input_path = args.next()?;
        let output_path = args.next()?;
        let password = Self::prompt_password()?;

        Some(Args {
            codec_type,
            input_path,
            output_path,
            password,
        })
    }

    fn parse_codec(raw: &str) -> Option<CodecType> {
        if raw == "encrypt" {
            return Some(CodecType::Encrypt);
        }
        if raw == "decrypt" {
            return Some(CodecType::Decrypt);
        }

        None
    }

    fn prompt_password() -> Option<String> {
        println!("Enter Password:");
        let password = read_password().ok()?;
        Some(password)
    }
}