use std::error::Error;
use std::process::ExitCode;

use aster_core::{Value, Vm};
use aster_storage::{Storage, StorageConfig};

const USAGE: &str = "Usage: aster [bootstrap | metadata put <key> <value> | metadata get <key>]";

#[tokio::main]
async fn main() -> ExitCode {
    match run().await {
        Ok(()) => ExitCode::SUCCESS,
        Err(error) => {
            eprintln!("aster: {error}");
            ExitCode::FAILURE
        }
    }
}

async fn run() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = std::env::args().skip(1).collect();
    match args
        .iter()
        .map(String::as_str)
        .collect::<Vec<_>>()
        .as_slice()
    {
        [] | ["bootstrap"] => {
            let mut vm = Vm::new()?;
            let root = vm.bootstrap();
            let class = vm.create_class("Example", root)?;
            let first = vm.create_instance(class)?;
            let second = vm.create_instance(class)?;
            vm.set_field(first, "message", Value::Text("Hello from Aster VM".into()))?;
            println!(
                "root={} parent={:?}",
                vm.class(root)?.name(),
                vm.class(root)?.parent()
            );
            println!(
                "class={} instances_distinct={} heap_objects={}",
                vm.class(class)?.name(),
                first != second,
                vm.object_count()
            );
            println!("bootstrap is independent of host storage");
        }
        ["help"] | ["--help"] | ["-h"] => println!("{USAGE}"),
        ["metadata", "put", key, value] => {
            let store = Storage::connect(&StorageConfig::from_env()?).await?;
            store.put(key, value).await?;
            println!("stored ({})", store.backend_name());
            store.close().await;
        }
        ["metadata", "get", key] => {
            let store = Storage::connect(&StorageConfig::from_env()?).await?;
            println!(
                "{}",
                store.get(key).await?.as_deref().unwrap_or("(missing)")
            );
            store.close().await;
        }
        _ => return Err(USAGE.into()),
    }
    Ok(())
}