fuzzel-pass 0.1.0

/// Provides Traits allowing to parse autotype data into `wtype` parameters
/// to be used by [`Wtype`]
///
/// [`Wtype`]: crate::shell::wtype::Wtype
mod autotype;

/// Provides error management utility types
mod error;

/// provides an utility to manage password file data
mod password;

/// provides shortcuts to different types from this crate.
mod prelude;

/// Provides utility to interact with system executables
mod shell;

pub(crate) use crate::autotype::Autotype;
use clap::Parser;
use std::process::ExitCode;

use prelude::*;

/// A `password-store` frontend for auto-typing passwords
#[derive(Parser)]
#[command(version, about, long_about = None)]
struct App {}

impl App {
    fn new() -> Self {
        Self::parse()
    }

    fn run(&self) -> Result<()> {
        let fuzzel = Fuzzel::default();
        let password_store = Pass::default();
        let wtype = Wtype::default();

        let password_list = password_store.list()?;
        let selection = fuzzel.pick(password_list)?;
        let field_list = password_store.show(selection)?;
        let password_data: Password = field_list.parse()?;
        let key = fuzzel.pick(password_data.menu())?;
        let value = password_data.get(&key).unwrap_or_default();

        let yt_params = match (key.as_str(), value.clone()) {
            ("autotype", at_value) => {
                let at = Autotype::from((at_value.clone(), password_data));
                at.into()
            }
            (_, value) => vec![value],
        };

        wtype.send_keys(yt_params)?;

        Ok(())
    }
}

fn main() -> ExitCode {
    if let Err(err) = App::new().run() {
        return process_error(err);
    }

    ExitCode::SUCCESS
}

fn process_error(err: Error) -> ExitCode {
    eprintln!("An error occurred: {}", err);
    ExitCode::FAILURE
}