mod dp_module;

#[cfg(feature="python")]
mod py_module;

pub use self::dp_module::*;

#[cfg(feature="wasm")]
use wasm_bindgen::prelude::*;

#[cfg(feature="wasm")]
#[wasm_bindgen]
pub fn wasm_find_subset(keys: String, targets: String, max_key_length: usize, max_target_length: usize, n_candidates: usize) -> String {
    let mut keys: Vec<i32> = keys.split(",").map(|x| x.trim().parse::<i32>().unwrap()).collect();
    if targets.contains(", ") {

        let mut targets: Vec<i32> = targets.split(",").map(|x| x.trim().parse::<i32>().unwrap()).collect();
        if keys.iter().sum::<i32>() != targets.iter().sum::<i32>() {
            let ks = keys.iter().sum::<i32>();
            let ts = targets.iter().sum::<i32>();
            return format!("The sums of two arrays must be the same values. key's sum is {}. target's sum is {}.", ks, ts);
        }
        let result: Vec<Vec<(Vec<i32>, Vec<i32>)>> = dp::sequence_matcher(&mut keys, &mut targets, max_key_length, max_target_length, n_candidates);
        let mut s: Vec<String> = vec![];
        if result.len() == 0 {
            return "No solution. You might want to increase maximum length.".to_string();
        }
        for r in result{
            let mut t: Vec<String> = vec![];
            for elem in r{
                let mut key_str = String::new();
                let mut target_str = String::new();
                for key in elem.0{
                    key_str.push_str(&key.to_string());
                    key_str.push_str(", ");
                }
                for target in elem.1{
                    target_str.push_str(&target.to_string());
                    target_str.push_str(", ");
                }
                t.push(format!("([{}] [{}])", key_str, target_str));
            }
            s.push(format!("[{}]\n", t.join(",  ")))
        }
        format!("[{}]\n", s.join(", "))
    } else {
        let res: Vec<Vec<i32>> = dp::find_subset(keys, targets.parse::<i32>().unwrap(), max_target_length);
        let mut r3: Vec<String> = vec![];
        if res.len() == 0 {
            return "No solution. You might want to increase maximum subset length.".to_string();
        }
        for r in res{
            let mut r2: String = r.into_iter().map(|x| format!("{}, ", x.to_string())).collect::<String>();
            r2 = format!("[{}]", r2).replace(", ]", "]");
            r3.push(r2);
        }
        let s: String = r3.join(", ");
        s
    }
}