use std::collections::HashMap;
use std::env;

use std::fs;

use serde::Deserialize;

    identities: HashMap<String, String>,

#[derive(Deserialize)]
struct IdentityKey {
    key: String,
}
#[derive(Deserialize)]
struct Identity {
    display_name: String,
    email: String,
    public_key: IdentityKey,
}

        let mut identities: HashMap<String, String> = HashMap::new();
        Self::load_identities(&mut identities, &repo_path.join(".pijul/identities")).unwrap_or(());
        match env::var("HOME") {
            Ok(home) => {
                Self::load_identities(
                    &mut identities,
                    &Path::new(&home).join(".config/pijul/identities"),
                )
                .unwrap_or(());
            }
            Err(..) => {}
        }

            identities,

    fn load_identities(
        identities: &mut HashMap<String, String>,
        dir: &Path,
    ) -> Result<(), Box<dyn Error>> {
        let files = fs::read_dir(dir)?;
        for file in files {
            match fs::read_to_string(dir.join(file?.path()).join("identity.toml")) {
                Ok(content) => {
                    let id: Identity = toml::from_str(&content)?;
                    identities.insert(
                        id.public_key.key,
                        format!("{} <{}>", id.display_name, id.email),
                    );
                }
                Err(..) => {}
            }
        }
        return Ok(());
    }

        if let Some(key) = a.0.get("key") {
            match self.identities.get(key) {
                Some(name) => {
                    return name.to_string();
                }
                None => {
                    return format!("{} <>", key);
                }
            }
        }

        }
        if let Some(key) = a.0.get("key") {
            return format!("{} <>", key);

serde = "1.0.156"
toml = "0.5.11"

 "serde",
 "toml",