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

struct Philosopher {
    name: String,
    left: usize,
    right: usize,
}

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

    fn eat(&self, table: &Table) {
        let _left = table.forks[self.left].lock().unwrap();
        let _right = table.forks[self.right].lock().unwrap();

        println!("{} 正在吃饭.", self.name);

        // 哲学家吃饭的时间
        thread::sleep_ms(1000);

        println!("{} 结束吃饭.", self.name);
    }

    fn think(&self) {
        println!("{} 在思考.", self.name);

        // 哲学家思考的时间
        thread::sleep_ms(1000);

        println!("{} 结束思考.", self.name);
    }
}

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

fn main() {
    // 哲学家数量
    let num_philosophers = 5;

    // 创建一个互斥锁的向量，每个元素表示一只餐叉
    let forks: Vec<Mutex<()>> = (0..num_philosophers)
        .map(|_| Mutex::new(()))
        .collect();

    // 创建一个互斥锁的向量，每个元素表示一位哲学家
    let philosophers: Vec<Philosopher> = (0..num_philosophers)
        .map(|i| {
            Philosopher::new(
                &format!("哲学家 {}", i),
                i,
                (i + 1) % num_philosophers,
            )
        })
        .collect();

    // 创建 Arc（原子引用计数）以便哲学家之间共享 Table
    let table = Arc::new(Table { forks });

    // 创建一个向量，用于存储线程句柄
    let handles: Vec<_> = philosophers
        .into_iter()
        .map(|p| {
            let table = table.clone();
            thread::spawn(move || {
                loop {
                    p.think();
                    p.eat(&table);
                }
            })
        })
        .collect();

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }
}