use rand::Rng;

fn main() {

    let cash_machines = vec![CashMachine::new(1), CashMachine::new(2), CashMachine::new(3), CashMachine::new(4), CashMachine::new(5)];

    // Methode B
    let pre_score_method_b = cash_machines.iter().map(|machine| {
        let score = machine.play_x_time(10);
        println!("Score pour la machine {} : {}", machine.number, score);
        score
    }).collect::<Vec<i32>>();

    let max = pre_score_method_b.iter().enumerate().map(|(x, y)| (y, x)).max().unwrap();
    println!("Meilleur machine d'après méthode B: {} avec score de {}", (max.1 + 1), max.0);
    let score_method_a: i32 = pre_score_method_b.iter().sum::<i32>() + cash_machines[max.1].play_x_time(500_000 - 50);
    println!("Score méthode B : {}", score_method_a);

    // method C
    let pre_score_method_c = cash_machines.iter().map(|machine| {
        let score = machine.play_x_time(1_000);
        println!("Score pour la machine {} : {}", machine.number, score);
        score
    }).collect::<Vec<i32>>();

    let max = pre_score_method_c.iter().enumerate().map(|(x, y)| (y, x)).max().unwrap();
    println!("Meilleur machine d'après méthode C: {} avec score de {}", (max.1 + 1), max.0);
    let score_method_c: i32 = pre_score_method_c.iter().sum::<i32>() + cash_machines[max.1].play_x_time(500_000 - 5_000);
    println!("Score méthode C : {}", score_method_c);

    // method D
    let score_method_d = cash_machines.iter().map(|machine| {
        let score = machine.play_x_time(100_000);
        println!("Score pour la machine {} : {}", machine.number, score);
        score
    }).sum::<i32>();
    println!("Score méthode D : {}", score_method_d);

}

enum PlayResult {
    WIN,
    LOOSE
}

struct CashMachine {
    number: i8,
    max: f32,
}

impl CashMachine {
    pub fn new(number: i8) -> CashMachine {
        let mut rng = rand::thread_rng();
        CashMachine {
            number: number,
            max: rng.gen::<f32>(),
        }
    }

    pub fn play(&self) -> PlayResult {
        let mut rng = rand::thread_rng();
        if rng.gen::<f32>() < self.max {
            PlayResult::WIN
        }
        else {
            PlayResult::LOOSE
        }
    }

    pub fn play_x_time(&self, time: i32) -> i32 {
        let mut score: i32 = 0;
        for _ in 1..=time {
            if let PlayResult::WIN = self.play() {
                score += 1
            }
        }
        score
    }
}