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

struct Philosopher {
    name: String,
    left_fork: usize,
    right_fork: usize,
}

impl Philosopher {
    fn new(name: &str, left_fork: usize, right_fork: usize) -> Philosopher {
        Philosopher {
            name: name.to_string(),
            left_fork: left_fork,
            right_fork: right_fork,
        }
    }

    fn eat(&self, table: &Table) {
        let _left = table.forks[self.left_fork].lock().unwrap();
        println!("{} взял(а) первую вилку.", self.name);
        thread::sleep(Duration::from_millis(1000));
        let _right = table.forks[self.right_fork].lock().unwrap();
        println!("{} взял(а) вторую вилку.", self.name);

        println!("{} начал(а) есть.", self.name);
        thread::sleep(Duration::from_millis(5000));
        println!(
            "{} закончил(а) есть и положил(а) обе вилки.",
            self.name
        );
    }
}

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

impl Table {
    fn new(places: usize) -> Table {
        let mut forks = Vec::new();
        for _ in 0..places {
            forks.push(Mutex::new(()));
        }
        Table { forks: forks }
    }
}

fn main() {
    let philosophers = vec![
        ("Андрей", 0, 1),
        ("Артем", 1, 2),
        ("Наташа", 0, 2),
    ];

    let philosophers: Vec<_> = philosophers
        .into_iter()
        .map(|p| Philosopher::new(p.0, p.1, p.2))
        .collect();

    let table = Arc::new(Table::new(philosophers.len()));

    let handles: Vec<_> = philosophers
        .into_iter()
        .map(|p| {
            let table = table.clone();

            thread::spawn(move || {
                p.eat(&table);
            })
        }).collect();

    for h in handles {
        h.join().unwrap();
    }
}