learning_edpyt_cargo 0.1.1

use rand::Rng;
use std::cmp::Ordering;
use std::{env, io};

fn main() {
    let args: Vec<String> = env::args().collect();
    match &args[..] {
        [_, player_name] => {
            let mut game = GuessingGame::new(player_name);
            game.start_game().unwrap();
        }
        _ => panic!("Provide `player_name` in argument and nothing else. :D"),
    }
}

struct GuessingGame<'a> {
    game_started: bool,
    player_name: &'a str,
}

impl<'a> GuessingGame<'a> {
    fn new(player_name: &'a str) -> Self {
        GuessingGame {
            game_started: false,
            player_name,
        }
    }

    pub fn start_game(&mut self) -> Result<bool, &'static str> {
        if self.game_started {
            return Err("Game already started!");
        }
        self.game_started = true;
        self.game();
        Ok(true)
    }

    fn game(&self) {
        println!("{}, guess the number!", self.player_name);
        let secret_number = rand::thread_rng().gen_range(1..=100);

        loop {
            println!("Please input your guess.");
            let mut guess = String::new();
            io::stdin()
                .read_line(&mut guess)
                .expect("Failed to read line.");
            let guess: u32 = match guess.trim().parse() {
                Ok(num) => num,
                Err(_) => continue,
            };
            println!("You guessed: {guess}");

            match guess.cmp(&secret_number) {
                Ordering::Less => println!("Too small!"),
                Ordering::Greater => println!("Too big!"),
                Ordering::Equal => {
                    println!("You win!");
                    break;
                }
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::GuessingGame;

    #[test]
    fn start_game() {
        let mut game = GuessingGame::new("edpyt");

        let game_started = game.start_game();

        assert!(game_started.is_ok());
        assert!(game_started.unwrap());
    }
}