fn main() {
    let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
    if let Some(result) = lazaret_linux::process::dispatch_private_process_role(&arguments) {
        if let Err(error) = result {
            eprintln!("private process role failed: {error}");
            std::process::exit(1);
        }
        return;
    }
    let current_workspace = std::env::current_dir().unwrap_or_else(|error| {
        eprintln!("cannot determine current workspace: {error}");
        std::process::exit(1);
    });
    let command = lazaret_client::cli::parse(arguments, current_workspace)
        .unwrap_or_else(|error| error.exit());
    match command {
        lazaret_client::cli::Command::State(command) => {
            match lazaret_client::state::run_command(command) {
                Ok(status) => std::process::exit(status),
                Err(error) => {
                    eprintln!("Lazaret state maintenance failed: {error}");
                    std::process::exit(1);
                }
            }
        }
        lazaret_client::cli::Command::Run(command) => run(&command),
    }
}

fn run(command: &lazaret_client::ClientCommand) {
    let mut backend = match lazaret_client::coordinator_backend::CoordinatorClientBackend::new() {
        Ok(backend) => backend,
        Err(error) => {
            eprintln!("Lazaret failed: {error}");
            std::process::exit(1);
        }
    };
    match lazaret_client::run(
        &mut backend,
        command,
        &mut std::io::stdout(),
        &mut std::io::stderr(),
    ) {
        Ok(status) => std::process::exit(status),
        Err(error) => {
            eprintln!("Lazaret failed: {error}");
            std::process::exit(1);
        }
    }
}