mumu-string 0.1.0

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

pub fn string_index_of_bridge(_interp: &mut mumu::parser::interpreter::Interpreter, args: Vec<Value>) -> Result<Value, String> {
    match args.len() {
        0 => Ok(make_two_arg_partial(string_index_of_finalize, None, None)),
        1 => Ok(make_two_arg_partial(string_index_of_finalize, Some(args[0].clone()), None)),
        2 => {
            let s = &args[0];
            let pat = &args[1];
            let s_pl = is_placeholder(s);
            let pat_pl = is_placeholder(pat);
            if !s_pl && !pat_pl {
                string_index_of_finalize(vec![s.clone(), pat.clone()])
            } else {
                Ok(make_two_arg_partial(
                    string_index_of_finalize,
                    if s_pl { None } else { Some(s.clone()) },
                    if pat_pl { None } else { Some(pat.clone()) },
                ))
            }
        }
        n => Err(format!("string:index_of => expected up to 2 arguments, got {}", n)),
    }
}

fn string_index_of_finalize(mut args: Vec<Value>) -> Result<Value, String> {
    if args.len() != 2 {
        return Err(format!(
            "string:index_of => finalize => expected 2 real args, got {}", args.len()));
    }
    let s_val = args.remove(0);
    let pat_val = args.remove(0);
    let s = match s_val {
        Value::SingleString(s) => s,
        Value::StrArray(ss) if ss.len() == 1 => ss[0].clone(),
        other => return Err(format!("string:index_of => first arg must be string, got {:?}", other)),
    };
    let pat = match pat_val {
        Value::SingleString(s) => s,
        Value::StrArray(ss) if ss.len() == 1 => ss[0].clone(),
        other => return Err(format!("string:index_of => second arg must be string, got {:?}", other)),
    };
    Ok(Value::Int(s.find(&pat).map(|i| {
        s[..i].chars().count() as i32
    }).unwrap_or(-1)))
}