use anyhow::Result;

use crate::config::{self, DEFAULTS_MEMORY, VALID_KEYS};

pub async fn action(args: &[String]) -> Result<()> {
    if args.is_empty() {
        let cfg = config::load().await;
        for key in VALID_KEYS {
            let display = match *key {
                "memory" => match &cfg.memory {
                    Some(v) => v.to_string(),
                    None => format!("{DEFAULTS_MEMORY} (default)"),
                },
                _ => "(unknown)".to_string(),
            };
            println!("{key} = {display}");
        }
        return Ok(());
    }

    let key = &args[0];
    if !VALID_KEYS.contains(&key.as_str()) {
        crate::fmt::die(&format!(
            "Unknown config key: {key}\nAvailable keys: {}",
            VALID_KEYS.join(", ")
        ));
    }

    if args.len() == 1 {
        let val = match key.as_str() {
            "memory" => config::get_memory().await,
            _ => None,
        };
        let default = match key.as_str() {
            "memory" => DEFAULTS_MEMORY,
            _ => "",
        };
        match val {
            Some(v) => println!("{v}"),
            None => println!("{default} (default)"),
        }
        return Ok(());
    }

    if args.len() > 2 {
        crate::fmt::die(&format!(
            "Too many arguments. Usage: sandlot config {key} <value>"
        ));
    }

    let value = &args[1];
    let normalized = match config::validate_memory(value) {
        Ok(v) => v,
        Err(_) => crate::fmt::die("Must be a number followed by G or M, minimum 512M (e.g. 16G)"),
    };
    config::set_memory(normalized.clone()).await?;
    println!("{key} = {normalized}");

    Ok(())
}