BlueArchiveToolkit/infrastructure/examples/official_launcher_bootstrap.rs

use bat_infrastructure::OfficialLauncherBootstrapService;
use std::env;
use std::path::PathBuf;

fn main() -> anyhow::Result<()> {
    let args = parse_args()?;
    let service = OfficialLauncherBootstrapService::with_curl_command(
        args.launcher_version,
        args.curl_command.to_string_lossy().to_string(),
    );
    let game_config = service.fetch_game_config().map_err(anyhow::Error::msg)?;
    let cdn_config = service.fetch_cdn_config().map_err(anyhow::Error::msg)?;

    println!("game_latest_version={}", game_config.game_latest_version);
    println!(
        "game_latest_file_path={}",
        game_config.game_latest_file_path
    );
    println!(
        "game_lowest_version={}",
        game_config
            .game_lowest_version
            .as_deref()
            .unwrap_or("<none>")
    );
    println!(
        "game_start_exe_name={}",
        game_config
            .game_start_exe_name
            .as_deref()
            .unwrap_or("<none>")
    );
    println!("game_start_params={:?}", game_config.game_start_params);
    println!("primary_cdn={}", cdn_config.primary_cdn);
    println!("backup_cdn={}", cdn_config.back_up_cdn);

    if args.manifest {
        let manifest_url = service
            .fetch_manifest_url(
                &game_config.game_latest_version,
                &game_config.game_latest_file_path,
            )
            .map_err(anyhow::Error::msg)?;
        let manifest = service
            .fetch_remote_manifest(&manifest_url.url)
            .map_err(anyhow::Error::msg)?;

        println!("manifest_url={}", manifest_url.url);
        println!(
            "manifest_source={}",
            manifest.source.as_deref().unwrap_or("<none>")
        );
        println!("manifest_file_count={}", manifest.files.len());
    }

    Ok(())
}

#[derive(Debug)]
struct CliArgs {
    launcher_version: String,
    curl_command: PathBuf,
    manifest: bool,
}

fn parse_args() -> anyhow::Result<CliArgs> {
    let raw_args = env::args().collect::<Vec<_>>();
    let mut args = raw_args.into_iter();
    let binary = args
        .next()
        .unwrap_or_else(|| "official_launcher_bootstrap".to_string());
    let mut parsed = CliArgs {
        launcher_version: "1.7.2".to_string(),
        curl_command: PathBuf::from("curl"),
        manifest: false,
    };

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--launcher-version" => parsed.launcher_version = next_option_value(&mut args, &flag)?,
            "--curl" => parsed.curl_command = PathBuf::from(next_option_value(&mut args, &flag)?),
            "--manifest" => parsed.manifest = true,
            "--help" | "-h" => {
                print_usage(&binary);
                std::process::exit(0);
            }
            _ => return Err(anyhow::anyhow!("unknown argument: {flag}")),
        }
    }

    Ok(parsed)
}

fn next_option_value(
    args: &mut impl Iterator<Item = String>,
    flag: &str,
) -> anyhow::Result<String> {
    args.next()
        .ok_or_else(|| anyhow::anyhow!("missing value for {flag}"))
}

fn print_usage(binary: &str) {
    eprintln!("usage: {binary} [--launcher-version 1.7.2] [--curl curl] [--manifest]");
}