use std::process;

use golgi::{
    api::friends::{FriendsHops, RelationshipQuery},
    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);

    // Define IDs (public keys) to follow and block.
    let to_follow = String::from("@5Pt3dKy2HTJ0mWuS78oIiklIX0gBz6BTfEnXsbvke9c=.ed25519");
    let to_block = String::from("@7Y4nwfQmVtAilEzi5knXdS2gilW7cGKSHXdXoT086LM=.ed25519");

    // Set the relationship of the local identity to the `to_follow` identity.
    // In this case, the `set_relationship` method publishes a `contact`
    // message which defines following as `true`.
    // A message reference is returned for the published `contact` message.
    let response = sbot_client
        .set_relationship(&to_follow, Some(true), None)
        .await?;

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

    // Set the relationship of the local identity to the `to_block` identity.
    // In this case, the `set_relationship` method publishes a `contact`
    // message which defines blocking as `true`.
    // A message reference is returned for the published `contact` message.
    let response = sbot_client
        .set_relationship(&to_block, None, Some(true))
        .await?;

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

    // Golgi also exposes convenience methods for following and blocking.
    // Here is an example of a simpler way to follow an identity.
    let _follow_response = sbot_client.follow(&to_follow).await?;

    // Blocking can be achieved in a similar fashion.
    let _block_response = sbot_client.block(&to_block).await?;

    // Get a list of peers within 0 hops of the local identity.
    // This returns a list of peers whom we follow.
    // If `max` is set to 1, the list will include the peers we follow plus
    // the peers that they follow.
    let follows = sbot_client
        .friends_hops(FriendsHops {
            max: 0,
            start: None,
            // The `reverse` parameter is not currently implemented in `go-sbot`.
            reverse: Some(false),
        })
        .await?;

    // Print the list of peers to `stdout`.
    println!("follows: {:?}", follows);

    // Determine if an identity (`source`) is following a second identity (`dest`).
    // This method will return `true` or `false`.
    let mref = sbot_client
        .friends_is_following(RelationshipQuery {
            source: id.clone(),
            dest: to_follow.clone(),
        })
        .await?;

    // Print the follow status to `stdout`.
    println!("isfollowingmref: {}", mref);

    // Determine if an identity (`source`) is blocking a second identity (`dest`).
    let mref = sbot_client
        .friends_is_blocking(RelationshipQuery {
            source: id.clone(),
            dest: to_block.clone(),
        })
        .await?;

    // Print the block status to `stdout`.
    println!("isblockingmref: {}", mref);

    let mref = sbot_client
        .friends_is_blocking(RelationshipQuery {
            source: id.clone(),
            dest: to_follow,
        })
        .await?;

    // Output should be `false`.
    println!("isblockingmref(should be false): {}", mref);

    let mref = sbot_client
        .friends_is_following(RelationshipQuery {
            source: id,
            dest: to_block.clone(),
        })
        .await?;

    // Output should be `false`.
    println!("isfollowingmref(should be false): {}", 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);
    }
}