use std::thread;
use std::time::Duration;
use std::sync::{Mutex, Arc};

struct Table {
    forks: Vec<Mutex<()>>,
}


enum Gender {
    Male,
    Female,
}

struct Philosopher {
    name: String,
    gender: Gender,
    hand_left: usize,
    hand_right: usize,
}

impl Philosopher {
    fn new(name: &str, gender: Gender, left: usize, right: usize) -> Philosopher {
        Philosopher {
            name: name.to_string(),
            gender: gender,
            hand_left: left,
            hand_right: right,
        }
    }

    fn eat_start (&self) {
        match self.gender {
            Gender::Male => println!("{} начал есть.", self.name),
            Gender::Female => println!("{} начала есть.", self.name),
        };
    }

    fn eat_end (&self) {
        match self.gender {
            Gender::Male => println!("{} закончил есть.", self.name),
            Gender::Female => println!("{} закончила есть.", self.name),
        };
    }

    fn eat_from(&self, table: &Table) {

        loop {
            println!("{} думает.", self.name);

            thread::sleep(Duration::from_millis(1000));

            let _left = match table.forks[self.hand_left].try_lock() {
                Ok(res) => res,
                Err(_) => continue,
            };

            let _right = match table.forks[self.hand_right].try_lock() {
                Ok(res) => res,
                Err(_) => continue,
            };

            self.eat_start();
            self.eat_end();

            break;
        }
    }
}

fn main() {
    let table = Arc::new(Table { forks: vec![
        Mutex::new(()),
        Mutex::new(()),
        Mutex::new(()),
        Mutex::new(()),
        Mutex::new(()),
    ]});


    let philosophers = vec![
        Philosopher::new("Джудит Батлер", Gender::Female, 0, 1),
        Philosopher::new("Рая Дунаевская", Gender::Female, 1, 2),
        Philosopher::new("Аристотель", Gender::Male, 2, 3),
        Philosopher::new("Эмма Гольдман", Gender::Female, 3, 4),
        Philosopher::new("Сократ", Gender::Male, 4, 0),
    ];

    // let mut handles: Vec<_> = vec![];

    // for philosopher in philosophers {
    //     let table = table.clone();
    //     handles.push(thread::spawn(move || {
    //         philosopher.eat_from(&table);
    //     }))
    // }

    let handles: Vec<_> = philosophers.into_iter().map(|p| {
        let table = table.clone();
        thread::spawn(move || {
            p.eat_from(&table);
        })
    }).collect();

    let mut index = 0;

    for h in handles {
        index += 1;
        match h.join() {
            Ok(_) => println!("Поток #{} завершен", index.to_string()),
            Err(_) => println!("поперхнулся"),
        };
    }
}