mumu-string 0.1.0

use mumu::parser::types::Value;
use crate::common::{is_placeholder, make_two_arg_partial};

pub fn string_join_bridge(_interp: &mut mumu::parser::interpreter::Interpreter, args: Vec<Value>) -> Result<Value, String> {
    match args.len() {
        0 => Ok(make_two_arg_partial(string_join_finalize, None, None)),
        1 => Ok(make_two_arg_partial(string_join_finalize, Some(args[0].clone()), None)),
        2 => {
            let sep = &args[0];
            let arr = &args[1];
            let sep_is_pl = is_placeholder(sep);
            let arr_is_pl = is_placeholder(arr);

            if !sep_is_pl && !arr_is_pl {
                string_join_finalize(vec![sep.clone(), arr.clone()])
            } else {
                Ok(make_two_arg_partial(
                    string_join_finalize,
                    if sep_is_pl { None } else { Some(sep.clone()) },
                    if arr_is_pl { None } else { Some(arr.clone()) },
                ))
            }
        }
        n => Err(format!("string:join => expected up to 2 arguments, got {}", n)),
    }
}

fn string_join_finalize(mut args: Vec<Value>) -> Result<Value, String> {
    if args.len() != 2 {
        return Err(format!("string:join => finalize => expected 2 real args, got {}", args.len()));
    }
    let sep_val = args.remove(0);
    let arr_val = args.remove(0);
    let arr = match arr_val {
        Value::StrArray(ss) => ss,
        other => return Err(format!("string:join => second arg (array) must be StrArray, got {:?}", other)),
    };
    let sep = match sep_val {
        Value::SingleString(s) => s,
        Value::StrArray(ss) if ss.len() == 1 => ss[0].clone(),
        other => return Err(format!("string:join => first arg (sep) must be string, got {:?}", other)),
    };
    Ok(Value::SingleString(arr.join(&sep)))
}