use std::process;

use kuska_ssb::api::dto::content::PubAddress;

use golgi::{messages::SsbMessageContent, sbot::Keystore, GolgiError, Sbot};

// Golgi is an asynchronous library so we must call it from within an
// async function. The `GolgiError` type encapsulates all possible
// error variants for the library.
async fn run() -> Result<(), GolgiError> {
    // Attempt to initialise a connection to an sbot instance using the
    // secret file at the Patchwork path and the default IP address, port
    // and network key (aka. capabilities key).
    let mut sbot_client = Sbot::init(Keystore::Patchwork, None, None).await?;

    // Call the `whoami` RPC method to retrieve the public key for the sbot
    // identity. This is our 'local' public key.
    let id = sbot_client.whoami().await?;

    // Print the public key (identity) to `stdout`.
    println!("whoami: {}", id);

    // Compose a `pub` address type message.
    let pub_address_msg = SsbMessageContent::Pub {
        address: Some(PubAddress {
            // IP address.
            host: Some("127.0.0.1".to_string()),
            // Port.
            port: 8009,
            // Public key.
            key: id,
        }),
    };

    // Publish the `pub` address message.
    // This step is required for successful invite code creation.
    let pub_msg_ref = sbot_client.publish(pub_address_msg).await?;

    // Print the message reference to `stdout`.
    println!("pub_msg_ref: {}", pub_msg_ref);

    // Generate an invite code that can be used 1 time.
    let invite_code = sbot_client.invite_create(1).await?;

    // Print the invite code to `stdout`.
    println!("invite (1 use): {:?}", invite_code);

    // Generate an invite code that can be used 7 times.
    let invite_code_2 = sbot_client.invite_create(7).await?;

    // Print the invite code to `stdout`.
    println!("invite (7 uses): {:?}", invite_code_2);

    // Define an invite code.
    let test_invite =
        "net:ssbroom2.commoninternet.net:8009~shs:wm8a1zHWjtESv4XSKMWU/rPRhnAoAiSAe4hQSY0UF5A=";

    // Redeem an invite code (initiating a mutual follow between the local
    // identity and the identity which generated the code (`wm8a1z...`).
    let mref = sbot_client.invite_use(test_invite).await?;

    // Print the message reference to `stdout`.
    println!("mref: {:?}", mref);

    Ok(())
}

// Enable an async main function and execute the `run()` function,
// catching any errors and printing them to `stderr` before exiting the
// process.
#[async_std::main]
async fn main() {
    if let Err(e) = run().await {
        eprintln!("Application error: {}", e);
        process::exit(1);
    }
}