use aws_sdk_ssm::{operation::get_parameters_by_path::GetParametersByPathOutput, types::Parameter};

#[::tokio::main]
async fn main() -> Result<(), aws_sdk_ssm::Error> {
    let args: Vec<String> = std::env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage: {} <path>", args[0]);
        std::process::exit(1);
    };

    let path = &args[1];

    let config = aws_config::load_from_env().await;
    let ssm = aws_sdk_ssm::Client::new(&config);

    for parameter in get_all_parameters_by_path(path, &ssm).await? {
        // path prefix を除去する
        let name = parameter
            .name
            .unwrap_or_default()
            .replace(&format!("{}/", path), "");

        println!("{}=\"{}\"", name, parameter.value.unwrap_or_default());
    }

    Ok(())
}

async fn get_all_parameters_by_path(
    path: &str,
    client: &aws_sdk_ssm::Client,
) -> Result<Vec<Parameter>, aws_sdk_ssm::Error> {
    let mut parameters = Vec::new();
    let mut next_token = None;

    loop {
        let response = get_parameters_by_path(path, next_token, client).await?;

        parameters.extend(response.parameters.unwrap_or_default());

        if let Some(token) = response.next_token {
            next_token = Some(token);
        } else {
            break;
        }
    }

    Ok(parameters)
}

async fn get_parameters_by_path(
    path: &str,
    next_token: Option<String>,
    client: &aws_sdk_ssm::Client,
) -> Result<GetParametersByPathOutput, aws_sdk_ssm::Error> {
    let mut request = client
        .get_parameters_by_path()
        .path(path)
        .recursive(true)
        .with_decryption(true);

    if let Some(token) = next_token {
        request = request.next_token(token);
    }

    let response = request.send().await?;

    Ok(response)
}