use rand::Rng;
use std::cmp::Ordering;

fn parse_input() -> Option<u32> {

    loop {

        let mut input = String::new();
        std::io::stdin()
        .read_line(&mut input)
        .unwrap();

        match input.trim().parse::<u32>() {

            Ok(output) => return Some(output),

            Err(why) => {

                match input.trim() {

                    "quit" | ":q" | "q" | "stop" | "exit" => { println!("Stopping..."); return None; }
                    _ => { println!("{} is not a number!", input); }

                }
            }
        };
    }
}

fn main() {

    println!("Welcome to bingame! Type \"quit\" anytime to stop playing.");
    println!("Provide an upward limit for generated numbers: ");
    let limit = parse_input().unwrap();
    game(limit)

}

fn numgen(limit: u32) -> Result<(u32, u32), bool> {

    // generate random number

    let nombre: u32 = rand::thread_rng().gen_range(0..limit);

    // convert number from decimal to binary notation

    let mut binvec = vec![];

    let mut countdown = nombre;

    while countdown > 0 {

        binvec.push(countdown % 2);
        countdown /= 2;

    }

    let mut binnery = String::new();

    for i in binvec {

        binnery = i.to_string() + &binnery;

    }

    let binnery = binnery.parse::<u32>();

    let binary = match binnery {

        Ok(binary) => { binary },
        Err(why) => { std::process::abort(); }
    };

    return Ok((nombre, binary));
}

fn game(limit: u32) {

    loop {

        let ans = numgen(limit).unwrap();
        let nombre = ans.0;
        let binary = ans.1;

        println!("Type {} in binary", nombre);
        let guess = parse_input().unwrap();

        match guess.cmp(&binary) {
            Ordering::Equal => {
                println!("That's correct! {} in binary is {}!", nombre, binary);
            }
            Ordering::Greater | Ordering::Less => {
                println!("Nope! {} in binary is {}!", nombre, binary);
            }
        }
    }
}