#[derive(Clone, Debug, Serialize, Deserialize)]

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]

use std::fs;

use std::{fs, path::PathBuf};

    /// Write an identity to disk.
    ///
    /// # Arguments
    /// * `replace_current` - If the new identity will replace an existing one
    fn write(&self, replace_current: bool) -> Result<(), anyhow::Error> {

    fn write_config(&self, identity_dir: &PathBuf) -> Result<(), anyhow::Error> {
        let config_data = toml::to_string_pretty(&self)?;
        let mut config_file = std::fs::File::create(identity_dir.join("identity.toml"))?;
        config_file.write_all(config_data.as_bytes())?;
        Ok(())
    }
    fn write_secret_key(&self, identity_dir: &PathBuf) -> Result<(), anyhow::Error> {
        let key_data = serde_json::to_string_pretty(&self.secret_key())?;
        let mut key_file = super::load::open_secret_file(&identity_dir.join("secret_key.json"))?;
        key_file.write_all(key_data.as_bytes())?;
        Ok(())
    }
    /// Write a complete identity to disk.
    fn write(&self) -> Result<(), anyhow::Error> {

            if !replace_current {
                bail!("An identity with that name already exists: {existing_identity}");
            }

            bail!("An identity with that name already exists: {existing_identity}");

        self.write_config(&identity_dir)?;
        self.write_secret_key(&identity_dir)?;

        let config_data = toml::to_string_pretty(&self)?;
        let mut config_file = std::fs::File::create(identity_dir.join("identity.toml"))?;
        config_file.write_all(config_data.as_bytes())?;
        let key_data = serde_json::to_string_pretty(&self.secret_key())?;
        let mut key_file = super::load::open_secret_file(&identity_dir.join("secret_key.json"))?;
        key_file.write_all(key_data.as_bytes())?;

        confirmed_identity.write(false)?;

        confirmed_identity.write()?;

        // Remove the old data
        let old_identity_path = path(&self.name, true)?;
        debug!("Removing old directory: {old_identity_path:?}");
        fs::remove_dir_all(old_identity_path).context("Could not remove old identity.")?;

        let changed_names = self.name != new_identity.name;
        // If changing the identity name, remove old directory
        if changed_names {
            let old_identity_path = path(&self.name, true)?;
            debug!("Removing old directory: {old_identity_path:?}");
            fs::remove_dir_all(old_identity_path).context("Could not remove old identity.")?;
            let new_identity_path = path(&new_identity.name, false)?;
            debug!("Creating new directory: {new_identity_path:?}");
            fs::create_dir_all(new_identity_path).context("Could not create new identity.")?;

        // Write the new data
        new_identity.write(true)?;

            new_identity.write()?;

        // Remove the old keychain entry if name has changed
        if self.name != new_identity.name {

            // Delete the existing password

        } else {
            // Write only the new data
            let identity_dir = path(&new_identity.name, false)?;
            if self.config != new_identity.config {
                new_identity.write_config(&identity_dir)?;
            }
            if self.secret_key() != new_identity.secret_key() {
                new_identity.write_secret_key(&identity_dir)?;
            }

#[derive(Debug, Clone, Serialize, Deserialize)]

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]

    let secret_key = libpijul::key::SKey::generate(expiry);

    let credentials = if let Some(mut key) = default.secret_key() {
        key.expires = expiry;
        Some(identity::Credentials::new(key, pw))
    } else {
        None
    };

        secret_key.public_key(),
        Some(identity::Credentials::new(
            secret_key.save(pw.as_deref()),
            pw,
        )),

        default.public_key,
        credentials,

#[derive(Clone, Debug, Serialize, Deserialize)]

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]

#[derive(Clone, Debug, Serialize, Deserialize)]

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]

#[derive(Clone, Debug, Serialize, Deserialize)]

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]