musichoard/examples/musicbrainz_api/browse.rs

use std::{thread, time};

use musichoard::{
    collection::musicbrainz::Mbid,
    external::musicbrainz::{
        api::{browse::BrowseReleaseGroupRequest, MusicBrainzClient},
        http::MusicBrainzHttp,
    },
};
use structopt::StructOpt;
use uuid::Uuid;

const USER_AGENT: &str = concat!(
    "MusicHoard---examples---musicbrainz-api---browse/",
    env!("CARGO_PKG_VERSION"),
    " ( musichoard@thenineworlds.net )"
);

#[derive(StructOpt)]
struct Opt {
    #[structopt(subcommand)]
    entity: OptEntity,
}

#[derive(StructOpt)]
enum OptEntity {
    #[structopt(about = "Browse release groups")]
    ReleaseGroup(OptReleaseGroup),
}

#[derive(StructOpt)]
enum OptReleaseGroup {
    #[structopt(about = "Browse release groups of an artist")]
    Artist(OptMbid),
}

#[derive(StructOpt)]
struct OptMbid {
    #[structopt(help = "MBID of the entity")]
    mbid: Uuid,
}

fn main() {
    let opt = Opt::from_args();

    println!("USER_AGENT: {USER_AGENT}");

    let http = MusicBrainzHttp::new(USER_AGENT).expect("failed to create API client");
    let mut client = MusicBrainzClient::new(http);

    match opt.entity {
        OptEntity::ReleaseGroup(opt_release_group) => match opt_release_group {
            OptReleaseGroup::Artist(opt_mbid) => {
                let mbid: Mbid = opt_mbid.mbid.into();
                let mut request = BrowseReleaseGroupRequest::artist(&mbid).with_max_limit();

                let mut response_counts: Vec<usize> = Vec::new();

                loop {
                    let response = client
                        .browse_release_group(&request)
                        .expect("failed to make API call");

                    for rg in response.release_groups.iter() {
                        println!("{rg:?}\n");
                    }

                    let offset = response.release_group_offset;
                    let count = response.release_groups.len();
                    response_counts.push(count);
                    let total = response.release_group_count;

                    println!("Release group offset           : {offset}");
                    println!("Release groups in this response: {count}");
                    println!("Release groups in total        : {total}");

                    let next_offset = offset + count;
                    if next_offset == total {
                        break;
                    }
                    request.with_offset(next_offset);

                    thread::sleep(time::Duration::from_secs(1));
                }

                println!(
                    "Total: {}={} release groups",
                    response_counts
                        .iter()
                        .map(|i| i.to_string())
                        .collect::<Vec<_>>()
                        .join("+"),
                    response_counts.iter().sum::<usize>(),
                );
            }
        },
    }
}