fn tokenizer(input: &str, length: usize) -> Vec<String> {
    let mut result = input
        .split(' ')
        .map(String::from)
        .collect::<Vec<String>>()
        .into_iter()
        .fold((0, vec![]), |(mut size, mut v), word| {
            if v.is_empty() || size + word.len() > length {
                size = word.len() + 1;
                v.push(word);
                let pos = v.len() - 1;
            } else {
                size += word.len() + 1;
                let pos = v.len() - 1;
                v[pos].push_str(format!(" {}", word).as_str());
            }

            (size, v)
        })
        .1;

    for i in 0..result.len() - 1 {
        if result[i].len() < length {
            let pad = length - result[i].len();
            if pad > 0 {
                let spaces: usize = result[i]
                    .chars()
                    .map(|c| if c == ' ' { 1 } else { 0 })
                    .sum();

                let replace_len = spaces / pad;

                // spaces == 1
                // pad % spaces == 0 -> pad / spaces + 1
                if pad % spaces == 0 {
                    // Replace all spaces for ' ' * (pad / spaces + 1)
                    result[i] = result[i].replace(" ", " ".repeat(pad / spaces + 1).as_str());
                // pad % spaces == spaces
                } else if false {
                    // find gcd(pad, spaces) and distribute amongst spaces
                    // Put the remainder spaces on the first instance of space
                    //result[i] = result[i].replace(" ", " ".repeat(pad / spaces + 1).as_str());
                }
            }
        }
    }

    result
}

fn main() {
    let case = format!("An yellow ballooner is above the sea");
    println!("Case {}", case);
    let len = 15;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // An       yellow
    // ballooner    is
    // above the sea

    let case = format!("An yellow egg shell is above the sea");
    println!("Case {}", case);
    let len = 18;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // An    yellow   egg
    // shell is above the
    // sea

    /*
    let case = format!("A blue flower Under the sun");
    println!("Case {}", case);
    let len = 6;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // A blue
    // flower
    // Under
    // the
    // sun

    let case = format!("A blue A blue A blue");
    println!("Case {}", case);
    let len = 6;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // A blue
    // A blue
    // A blue

    let case = format!("A blue A blue A blue A blue");
    println!("Case {}", case);
    let len = 12;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // A blue A
    // blue A blue
    // A blue

    let case = format!("A blue flower Under the sun");
    println!("Case {}", case);
    let len = 7;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // A blue
    // flower
    // Under
    // the sun

    let case = format!("An yellow balloon is above the sea");
    println!("Case {}", case);
    let len = 9;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // An yellow
    // balloon
    // is  above
    // the sea

    let case = format!("An yellow ballooner is above the sea");
    println!("Case {}", case);
    let len = 9;
    tokenizer(case.as_str(), len).into_iter().for_each(|line| {
        assert!(line.len() <= len);
        println!("{}", line);
    });
    // Expected output
    // An yellow
    // ballooner
    // is above
    // the sea
    // */
}