BlueArchiveToolkit/adapters/examples/yostar_jp_discovery.rs

use bat_adapters::official::yostar_jp::{
    PatchPlatform, YostarJpResourceEndpoint, YostarJpResourceEndpointKind, YostarJpServerInfo,
};
use std::env;
use std::fs;

fn main() -> anyhow::Result<()> {
    let args = env::args().collect::<Vec<_>>();
    if args.len() < 2 {
        print_usage(&args[0]);
        std::process::exit(2);
    }

    let server_info_path = &args[1];
    let connection_group = args.get(2).map(String::as_str).unwrap_or("Prod-Audit");
    let app_version = args.get(3).map(String::as_str).unwrap_or("1.70.0");
    let platforms = args
        .get(4)
        .map(|value| parse_platforms(value))
        .transpose()
        .map_err(anyhow::Error::msg)?
        .unwrap_or_else(|| vec![PatchPlatform::Windows, PatchPlatform::Android]);

    let data = fs::read(server_info_path)?;
    let server_info = YostarJpServerInfo::from_slice(&data)?;
    let plan = server_info
        .discovery_plan(connection_group, app_version, &platforms)
        .map_err(anyhow::Error::msg)?;

    println!("connection_group={}", plan.connection_group_name);
    println!("app_version={}", plan.app_version);
    println!(
        "bundle_version={}",
        plan.bundle_version.as_deref().unwrap_or("<none>")
    );
    println!("addressables_root={}", plan.addressables_root);
    println!();

    for endpoint in &plan.endpoints {
        println!(
            "{}\t{}\t{}",
            endpoint_kind_label(endpoint.kind),
            platform_label(endpoint),
            endpoint.url
        );
    }

    Ok(())
}

fn print_usage(binary: &str) {
    eprintln!(
        "usage: {binary} <server-info.json> [connection-group] [app-version] [platforms]\n\
         platforms: comma-separated Windows,Android"
    );
}

fn parse_platforms(value: &str) -> Result<Vec<PatchPlatform>, String> {
    value
        .split(',')
        .map(str::trim)
        .filter(|part| !part.is_empty())
        .map(parse_platform)
        .collect()
}

fn parse_platform(value: &str) -> Result<PatchPlatform, String> {
    match value.to_ascii_lowercase().as_str() {
        "windows" | "win" => Ok(PatchPlatform::Windows),
        "android" => Ok(PatchPlatform::Android),
        _ => Err(format!("unsupported platform: {value}")),
    }
}

fn endpoint_kind_label(kind: YostarJpResourceEndpointKind) -> &'static str {
    match kind {
        YostarJpResourceEndpointKind::TableCatalog => "table_catalog",
        YostarJpResourceEndpointKind::TableCatalogHash => "table_catalog_hash",
        YostarJpResourceEndpointKind::AddressablesCatalog => "addressables_catalog",
        YostarJpResourceEndpointKind::AddressablesCatalogHash => "addressables_catalog_hash",
        YostarJpResourceEndpointKind::BundlePackingInfo => "bundle_packing_info",
        YostarJpResourceEndpointKind::BundlePackingInfoHash => "bundle_packing_info_hash",
        YostarJpResourceEndpointKind::MediaCatalog => "media_catalog",
        YostarJpResourceEndpointKind::MediaCatalogHash => "media_catalog_hash",
    }
}

fn platform_label(endpoint: &YostarJpResourceEndpoint) -> &'static str {
    endpoint
        .platform
        .map(PatchPlatform::as_str)
        .unwrap_or("shared")
}