use std::io::Write;

use crate::identity::Complete;

}
/// Associate a generated key with a remote identity. Patches authored
/// by unproven keys will only display the key as the author.
pub async fn prove(
    identity: &Complete,
    origin: Option<&str>,
    no_cert_check: bool,
) -> Result<(), anyhow::Error> {
    let remote = origin.unwrap_or(&identity.config.author.origin);
    let mut stderr = std::io::stderr();
    writeln!(
        stderr,
        "Linking identity `{}` with {}@{}",
        &identity.name, &identity.config.author.username, remote
    )?;
    let mut remote = if let Ok(repo) = Repository::find_root(None) {
        repository(
            &repo,
            None,
            Some(&identity.config.author.username),
            &remote,
            libpijul::DEFAULT_CHANNEL,
            no_cert_check,
            false,
        )
        .await?
    } else {
        unknown_remote(
            None,
            Some(&identity.config.author.username),
            &remote,
            libpijul::DEFAULT_CHANNEL,
            no_cert_check,
            false,
        )
        .await?
    };
    let (key, _password) = identity
        .credentials
        .clone()
        .unwrap()
        .decrypt(&identity.name)?;
    remote.prove(key).await?;
    Ok(())

pub use create::NO_CERT_CHECK;

    credentials: Option<Credentials>,

    pub credentials: Option<Credentials>,

use crate::remote;
use pijul_repository::Repository;

use log::{debug, error, warn};

use log::{debug, warn};

use std::sync::OnceLock;

pub static NO_CERT_CHECK: OnceLock<bool> = OnceLock::new();

        if Confirm::new()?
            .with_prompt("Do you want to link this identity to a remote?")
            .with_default(true)
            .interact()?
        {
            new_identity.prompt_remote().await?;

            // There are 3 cases that require re-proving:
            // 1: new identity (replace_current == None)
            // 2: new secret key
            // 3. new username/origin
            if !will_replace
                || self.secret_key() != new_identity.secret_key()
                || (&self.config.author.origin, &self.config.author.username)
                    != (
                        &new_identity.config.author.origin,
                        &new_identity.config.author.username,
                    )

        if link_remote {
            if Confirm::new()?
                .with_prompt("Do you want to link this identity to a remote?")
                .with_default(true)
                .interact()?

                // Prove the identity to the server
                if link_remote
                    && new_identity
                        .prove(None, *NO_CERT_CHECK.get_or_init(|| false))
                        .await
                        .is_err()
                {
                    error!("Could not prove identity `{}`. Please check your credentials & network connection. If you are on an enterprise network, perhaps try running with `--no-cert-check`. Your data is safe but will not be connected to {} without runnning `pijul identity prove {}`", new_identity.name, new_identity.config.author.origin, new_identity.name);
                }

                new_identity.prompt_remote().await?;
            } else {
                // The user wants an 'offline' identity, so make sure not to store login info
                new_identity.config.key_path = None;
                new_identity.config.author.username = String::new();
                new_identity.config.author.origin = String::new();

        } else {
            // The user wants an 'offline' identity, so make sure not to store login info
            new_identity.config.key_path = None;
            new_identity.config.author.username = String::new();
            new_identity.config.author.origin = String::new();

    /// Associate a generated key with a remote identity. Patches authored
    /// by unproven keys will only display the key as the author.
    pub async fn prove(
        &self,
        origin: Option<&str>,
        no_cert_check: bool,
    ) -> Result<(), anyhow::Error> {
        let remote = origin.unwrap_or(&self.config.author.origin);
        let mut stderr = std::io::stderr();
        writeln!(
            stderr,
            "Linking identity `{}` with {}@{}",
            &self.name, &self.config.author.username, remote
        )?;

        let mut remote = if let Ok(repo) = Repository::find_root(None) {
            remote::repository(
                &repo,
                None,
                Some(&self.config.author.username),
                &remote,
                libpijul::DEFAULT_CHANNEL,
                no_cert_check,
                false,
            )
            .await?
        } else {
            crate::remote::unknown_remote(
                None,
                Some(&self.config.author.username),
                &remote,
                libpijul::DEFAULT_CHANNEL,
                no_cert_check,
                false,
            )
            .await?
        };
        let (key, _password) = self.credentials.clone().unwrap().decrypt(&self.name)?;
        remote.prove(key).await?;
        Ok(())
    }

use crate::remote;

use log::warn;

use log::{info, warn};

        crate::identity::NO_CERT_CHECK
            .set(self.no_cert_check)
            .unwrap();

                if let Err(_) = remote::prove(&identity, None, self.no_cert_check).await {
                    warn!("Could not prove identity `{}`. Please check your credentials & network connection. If you are on an enterprise network, perhaps try running with `--no-cert-check`. Your data is safe but will not be connected to {} without runnning `pijul identity prove {}`", identity.name, identity.config.author.origin, identity.name);
                } else {
                    info!("Identity `{}` was proved to the server", identity);
                }

                Complete::load(&identity_name.unwrap_or(choose_identity_name(no_prompt).await?))?
                    .prove(server.as_deref(), self.no_cert_check)
                    .await?;

                let identity_name =
                    &identity_name.unwrap_or(choose_identity_name(no_prompt).await?);
                let loaded_identity = Complete::load(identity_name)?;
                remote::prove(&loaded_identity, server.as_deref(), self.no_cert_check).await?;

                old_identity.replace_with(new_identity)?;

                old_identity.clone().replace_with(new_identity.clone())?;
                // There are 2 cases that require re-proving:
                // 1: new secret key
                // 2. new username/origin
                if !options.no_link {
                    if new_identity.secret_key() != old_identity.secret_key()
                        || old_identity.config.author != new_identity.config.author
                    {
                        let prove_result =
                            remote::prove(&new_identity, None, self.no_cert_check).await;
                        if let Err(_) = prove_result {
                            warn!("Could not prove identity `{}`. Please check your credentials & network connection. If you are on an enterprise network, perhaps try running with `--no-cert-check`. Your data is safe but will not be connected to {} without runnning `pijul identity prove {}`", new_identity.name, new_identity.config.author.origin, new_identity.name);
                        } else {
                            info!("Identity `{}` was proved to the server", new_identity);
                        }
                    }
                }