async fn main() -> anyhow::Result<()> {

    let args = Args::parse();

    if let Some(shell) = args.completions {

        generate(shell, &mut Args::command(), "write", &mut std::io::stdout());

        return Ok(());

    }

    let mut message = String::new();

    std::io::stdin()

        .read_to_string(&mut message)

        .context("failed to read message from stdin")?;

    let mut conn = zlink::tokio::unix::connect(DEFAULT_CLIENT_SERVER_SOCKET_PATH)

        .await

        .with_context(|| {

            format!("failed to connect to roowho2 at {DEFAULT_CLIENT_SERVER_SOCKET_PATH}")

        })?;

    let user = args

        .user

        .expect("required_unless_present=completions guarantees this is set");

    let stdin = io::stdin();

    let source_tty = if !unistd::isatty(stdin.as_fd()).unwrap_or(false) {

        None

        unistd::ttyname(stdin.as_fd())

            .ok()

            .map(|p| p.to_string_lossy().to_string())

    VarlinkWalldClientProxy::write(&mut conn, source_tty, user, args.ttyname, message)

        .await

        .context("varlink call to walld failed")?

        .map_err(|err| anyhow::format_err!("{err}"))

        .and_then(|res| {

            if let VarlinkWalldClientResponse::Write(r) = res {

                Ok(r)

                Err(anyhow::format_err!(

                    "unexpected response from walld: {:?}",

                    res

                ))

        })?;

    Ok(())

}