use common::identity::{prompt, Identity, SubCommand, DEFAULT_PASSWORD};

use common::identity::{default, prompt, Identity, SubCommand};

    let identity = Identity::new(id_name("new_minimal"), None, None, None, None)?;

    let identity = Identity::new(id_name("new_minimal"), None, None, None, None, None, None)?;
    identity.run(SubCommand::New)?;
    Ok(())
}
#[test]
fn new_full() -> Result<(), Error> {
    let identity = Identity::new(
        id_name("new_full"),
        Some(default::FULL_NAME.to_string()),
        Some(Interaction::new(
            prompt::EMAIL,
            InteractionType::Input(default::EMAIL.to_string()),
        )),
        Some(Interaction::new(
            prompt::EXPIRY_DATE,
            InteractionType::Input(default::EXPIRY.to_string()),
        )),
        Some(Interaction::new(
            prompt::LOGIN,
            InteractionType::Input(default::LOGIN.to_string()),
        )),
        Some(Interaction::new(
            prompt::ORIGIN,
            InteractionType::Input(default::ORIGIN.to_string()),
        )),
        Some(Interaction::new(
            prompt::PASSWORD,
            InteractionType::Password {
                input: default::PASSWORD.to_string(),
                confirm: Some(prompt::PASSWORD_REPROMPT.to_string()),
            },
        )),
    )?;

fn new_encrypted() -> Result<(), Error> {

fn new_email() -> Result<(), Error> {

        id_name("new_encrypted"),

        id_name("new_email"),
        None,
        Some(Interaction::new(
            prompt::EMAIL,
            InteractionType::Input(default::EMAIL.to_string()),
        )),
        None,
        None,

    )?;
    identity.run(SubCommand::New)?;
    Ok(())
}
#[test]
fn new_expiry() -> Result<(), Error> {
    let identity = Identity::new(
        id_name("new_expiry"),

        None,

            prompt::ENCRYPTION_CONFIRM,

            prompt::EXPIRY_DATE,
            InteractionType::Input(default::EXPIRY.to_string()),
        )),
        None,
        None,
        None,
    )?;
    identity.run(SubCommand::New)?;
    Ok(())
}
#[test]
fn new_login() -> Result<(), Error> {
    let identity = Identity::new(
        id_name("new_login"),
        None,
        None,
        None,
        Some(Interaction::new(
            prompt::LOGIN,
            InteractionType::Input(default::LOGIN.to_string()),
        )),
        None,
        None,
    )?;
    identity.run(SubCommand::New)?;
    Ok(())
}
#[test]
fn new_origin() -> Result<(), Error> {
    let identity = Identity::new(
        id_name("new_origin"),
        None,
        None,
        None,
        None,
        Some(Interaction::new(
            prompt::ORIGIN,
            InteractionType::Input(default::ORIGIN.to_string()),
        )),
        None,
    )?;
    identity.run(SubCommand::New)?;
    Ok(())
}
#[test]
fn new_password() -> Result<(), Error> {
    let identity = Identity::new(
        id_name("new_password"),
        None,
        None,
        None,
        None,
        None,
        Some(Interaction::new(
            prompt::PASSWORD,

                input: DEFAULT_PASSWORD.to_string(),
                confirm: Some(prompt::PASSWORD_CONFIRM.to_string()),

                input: default::PASSWORD.to_string(),
                confirm: Some(prompt::PASSWORD_REPROMPT.to_string()),

    process::{
        unix::{PtyStream, UnixProcess},
        NonBlocking,
    },

    process::{unix::UnixProcess, NonBlocking},

        if let Some(second_input) = &self.second_attempt {

        if self.second_attempt.is_some() {

use std::{ffi::OsStr, path::PathBuf, process::Command};

use std::{ffi::OsStr, io::Read, path::PathBuf, process::Command};

pub const DEFAULT_FULL_NAME: &str = "Firstname Lastname";
pub const DEFAULT_EMAIL: &str = "person@example.com";
pub const DEFAULT_EXPIRY: &str = "2056-01-01";
pub const DEFAULT_LOGIN: &str = "my_username";
pub const DEFAULT_ORIGIN: &str = "ssh.pijul.com";
pub const DEFAULT_PASSWORD: &str = "correct-horse-battery-staple";

pub mod default {
    pub const FULL_NAME: &str = "Firstname Lastname";
    pub const EMAIL: &str = "person@example.com";
    pub const EXPIRY: &str = "2056-01-01";
    pub const LOGIN: &str = "my_username";
    pub const ORIGIN: &str = "ssh.pijul.com";
    pub const PASSWORD: &str = "correct-horse-battery-staple";
}

    pub const EXPIRY_CONFIRM: &str = "Do you want this key to expire?";

    pub const REMOTE_CONFIRM: &str = "Do you want to link this identity to a remote?";
    pub const REMOTE_USERNAME: &str = "Remote username";
    pub const REMOTE_ADDRESS: &str = "Remote URL";
    pub const ENCRYPTION_CONFIRM: &str = "Do you want to change the encryption?";

    pub const LOGIN: &str = "Remote username";
    pub const ORIGIN: &str = "Remote URL";

    pub const PASSWORD_CONFIRM: &str = "Secret key password";

    pub const PASSWORD_REPROMPT: &str = "Confirm password";
    pub mod confirm {
        pub const EXPIRY: &str = "Do you want this key to expire?";
        pub const REMOTE: &str = "Do you want to link this identity to a remote?";
        pub const ENCRYPTION: &str = "Do you want to change the encryption?";
    }

login = '";

login = ''";

    pub login: Option<Interaction>,
    pub origin: Option<Interaction>,

        login: Option<Interaction>,
        remote: Option<Interaction>,

            login,
            origin: remote,

        let config_data = format!("{CONFIG_DATA}{DEFAULT_LOGIN}'");
        std::fs::write(&config_path, config_data)?;

        std::fs::write(&config_path, CONFIG_DATA)?;

        // TODO: handle more complex fields

        println!(
            "Login: {:?} (should be {:?})",
            toml_data.get("login"),
            self.login
                .clone()
                .and_then(|x| Some(x.valid_input().as_string()))
        );
        if let Some(login) = &self.login {
            assert_eq!(
                login.valid_input().as_string().as_str(),
                toml_data.get("login").unwrap().as_str().unwrap()
            );
        } else {
            let default = toml::value::Value::String(String::new());
            let data = toml_data.get("login").unwrap_or(&default).as_str().unwrap();
            assert!(data.is_empty() || data == whoami::username());
        }
        if let Some(origin) = &self.origin {
            assert_eq!(
                origin.valid_input().as_string().as_str(),
                toml_data.get("origin").unwrap().as_str().unwrap()
            );
        } else {
            let default = toml::value::Value::String(String::new());
            let data = toml_data
                .get("origin")
                .unwrap_or(&default)
                .as_str()
                .unwrap();
            assert!(data.is_empty() || data == "ssh.pijul.com");
        }
        if let Some(expiry) = &self.expiry {
            let time_stamp = toml_data
                .get("public_key")
                .unwrap()
                .get("expires")
                .unwrap()
                .as_str()
                .unwrap();
            let timestamp = dateparser::parse_with_timezone(&time_stamp, &chrono::offset::Utc)?;
            assert_eq!(
                expiry.valid_input().as_string(),
                timestamp.format("%Y-%m-%d").to_string()
            );
        } else {
            assert!(toml_data
                .get("public_key")
                .unwrap()
                .get("expires")
                .is_none());
        }
        let mut secret_key_file = std::fs::File::open(
            self.config_path
                .join("identities")
                .join(self.id_name.valid_input().as_string())
                .join("secret_key.json"),
        )?;
        let mut secret_key_text = String::new();
        secret_key_file.read_to_string(&mut secret_key_text)?;
        let secret_key: libpijul::key::SecretKey = serde_json::from_str(&secret_key_text)?;
        assert_eq!(secret_key.encryption.is_some(), self.password.is_some());

        if let Some(password) = &self.password {
            assert!(secret_key
                .load(Some(password.valid_input().as_string().as_str()))
                .is_ok());
        } else {
            assert!(secret_key.load(None).is_ok());
        }

                    pijul_cmd.arg("--name").arg(expiry.get_input(should_fail));

                    pijul_cmd.arg("--expiry").arg(expiry.get_input(should_fail));
                }
                if let Some(login) = self.login.clone() {
                    pijul_cmd.arg("--login").arg(login.get_input(should_fail));
                }
                if let Some(origin) = self.origin.clone() {
                    pijul_cmd.arg("--origin").arg(origin.get_input(should_fail));
                }
                if self.password.is_some() {
                    pijul_cmd.arg("--read-password");

        let mut session = Session::spawn(pijul_cmd)?;
        if let Some(password) = self.password.clone() {
            password.interact(&mut session)?;
        }

        Ok(Session::spawn(pijul_cmd)?.wait()?)

        Ok(session.wait()?)

            format!("{} (Current expiry: never)", prompt::EXPIRY_CONFIRM),
            InteractionType::Confirm(false),

            format!("{} (Current expiry: never)", prompt::confirm::EXPIRY),
            InteractionType::Confirm(self.expiry.is_some()),

        if let Some(expiry) = self.expiry.clone() {
            expiry.interact(&mut session)?;
        }

        Interaction::new(prompt::REMOTE_CONFIRM, InteractionType::Confirm(false))
            .interact(&mut session)?;

        let remote_data = self.login.is_some() || self.origin.is_some();
        Interaction::new(
            prompt::confirm::REMOTE,
            InteractionType::Confirm(remote_data),
        )
        .interact(&mut session)?;
        if remote_data {
            if let Some(login) = self.login.clone() {
                login.interact(&mut session)?;
            } else {
                // Use an empty login
                Interaction::new(prompt::LOGIN, InteractionType::Input(String::new()))
                    .interact(&mut session)?;
            }
            if let Some(origin) = self.origin.clone() {
                origin.interact(&mut session)?;
            } else {
                // Use an empty origin
                Interaction::new(prompt::ORIGIN, InteractionType::Input(String::new()))
                    .interact(&mut session)?;
            }
        }

                prompt::ENCRYPTION_CONFIRM

                prompt::confirm::ENCRYPTION

    pijul_cmd.arg("--no-link");

                if let Err(e) = old_identity.clone().create(no_prompt).await {

                if let Err(e) = old_identity.clone().create(no_prompt, true).await {

                        Complete::default()?.create(no_prompt).await?;

                        Complete::default()?.create(no_prompt, true).await?;

        self.identity.public_key.expires = if Confirm::with_theme(config.as_ref())

        let expiry = if Confirm::with_theme(config.as_ref())

        // Update the expiry AFTER potential secret key reset
        self.identity.public_key.expires = expiry;

    pub async fn create(self, no_prompt: bool) -> Result<Self, IdentityCreateError> {

    /// * `link_remote` - Override if the identity should be exchanged with the remote.
    pub async fn create(
        self,
        no_prompt: bool,
        link_remote: bool,
    ) -> Result<Self, IdentityCreateError> {

        if confirmed_identity.link_remote
            && confirmed_identity

        if link_remote && confirmed_identity.link_remote {
            if confirmed_identity

        {
            return Err(IdentityCreateError::ProveFailed(
                confirmed_identity.name.clone(),
            ));

            {
                return Err(IdentityCreateError::ProveFailed(
                    confirmed_identity.name.clone(),
                ));
            }

        /// If enabled, the program should not automatically prove the identity with given remote details
        #[clap(long = "no-link")]
        pub no_link: bool,

        #[clap(long = "login", requires("remote-details"), group("remote-details"))]

        #[clap(long = "login")]

        #[clap(long = "origin", requires("remote-details"), group("remote-details"))]

        #[clap(long = "origin")]

        /// If no-prompt is enabled, read password from stdin
        #[clap(long = "read-password")]
        pub password: bool,

    password: bool,

    // Make a new, identity based upon the info given
    let public_key = if let Some(date) = expiry {
        let mut pk = default.identity.public_key.clone();
        pk.expires = Some(date);
        pk

    let pw = if password {
        Some(
            dialoguer::Password::with_theme(config::load_theme()?.as_ref())
                .with_prompt("Secret key password")
                .with_confirmation("Confirm password", "Password mismatch")
                .interact()?,
        )

        default.identity.public_key

        None

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

        password: None,
        secret_key: default.secret_key,

        password: pw.clone(),
        secret_key: secret_key.save(pw.as_ref().map(|x| x.as_str())),

            public_key,

            public_key: secret_key.public_key(),

                        options.password,

                identity.create(options.no_prompt).await?;

                identity.create(options.no_prompt, !options.no_link).await?;

                        false,