mod pass;
mod rbw;
mod sh;

use std::env;
use std::io::{Error, ErrorKind};

const ENV_VAR_DEFAULT_VAULT: &str = "PASS_VAULT";

fn main() -> Result<(), Error> {
    pass::check_pass()?;
    rbw::check_rbw()?;

    let vaults = pass::get_vaults()?.vaults;
    if vaults.len() <= 0 {
        return Err(Error::new(ErrorKind::Other, "No vaults found"));
    }
    let vault_names = vaults
        .iter()
        .map(|vault| vault.name.clone())
        .collect::<Vec<String>>();

    let vault;
    match env::var(ENV_VAR_DEFAULT_VAULT) {
        Ok(default_vault) => {
            if vault_names.contains(&default_vault) {
                vault = default_vault;
            } else {
                return Err(Error::new(
                    ErrorKind::Other,
                    format!("Vault {} does not exist", default_vault),
                ));
            }
        }
        Err(_) => {
            vault = vault_names.get(0).unwrap().clone();
            println!(
                "No default vault found (you can set it with {}), using {}...",
                ENV_VAR_DEFAULT_VAULT, vault
            );
        }
    };

    let pass_items = pass::get_items(&vault)?;
    let mut pass_logins = pass::get_logins(pass_items);
    println!("{:?}", pass_logins[0]);
    println!("{}", pass_logins.len());

    let rbw_items = rbw::get_items()?;
    let mut rbw_logins = rbw::get_logins(rbw_items)?;
    println!("{:?}", rbw_logins[0]);
    println!("{}", rbw_logins.len());

    for rbw_login in rbw_logins.clone().iter() {
        let mut pass_login: Option<&pass::LoginItem> = None;

        'inner: for pass_login_iter in pass_logins.iter() {
            if rbw_login.name == pass_login_iter.title {
                println!("found match! {}", rbw_login.name);
                pass_login = Some(pass_login_iter);
                break 'inner;
            }
        }

        if let None = pass_login {
            println!("no match found for {}!", rbw_login.name);
            continue;
        }
        let pass_login = pass_login.unwrap();

        let rbw_password = rbw_login.password.clone();
        let pass_password = pass_login.password.clone();

        let rbw_user = rbw_login.user.clone();
        let pass_user = match pass_login.username.is_empty() {
            true => pass_login.email.clone(),
            false => pass_login.username.clone(),
        };
        let pass_user_is_actually_email = pass_user == pass_login.email;

        if rbw_password == pass_password {
            let rbw_index = rbw_logins
                .iter()
                .position(|x| x.id == rbw_login.id)
                .unwrap();
            rbw_logins.remove(rbw_index);

            let pass_index = pass_logins
                .iter()
                .position(|x| x.id == pass_login.id)
                .unwrap();
            pass_logins.remove(pass_index);
            continue;
        } else {
            println!(
                "password doesn't match! '{}' / '{}'",
                rbw_password, pass_password
            );
        }
    }

    println!("remaining {} rbw items", rbw_logins.len());
    println!("{:?}", rbw_logins);
    println!("remaining {} pass items", pass_logins.len());
    println!("{:?}", pass_logins);

    return Ok(());
}