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


pub type Job = Box<dyn FnOnce() + Send + 'static>;

/// A ThreadPool that runs the given task with the given threads.
/// If all the threads are occupied then it waits until a new thread is available.
pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: Sender<Message>,
}

struct Worker {
    thread: Option<thread::JoinHandle<()>>,
    id: usize,
}

enum Message {
    Terminate,
    Job(Job)
}

impl ThreadPool {

    /// Returns a new instce of ThreadPool.
    /// The ThreadPool::new() method takes an argument which is the number of threads
    /// the threadpool has.
    /// 
    /// # Examples
    /// 
    /// ```
    /// let pool = ThreadPool::new(4);
    /// ```
    pub fn new(size: usize) -> Self {
        let (sender, reciever) = mpsc::channel();
        let reciever = Arc::new(Mutex::new(reciever));

        let mut workers = Vec::with_capacity(size);

 

        for id in 0..size {
            let reciever = Arc::clone(&reciever);

            workers.push(Worker { thread: Some(thread::spawn(move || loop {
                let msg: Message = match reciever.lock().unwrap().recv() {

                    Ok(n) => n,

                    Err(_) => continue,

                };

                match msg {
                    Message::Job(msg) => {
                        msg()
                    },
                    _ => {
                        break;
                    }
                }
            })), id: id + 1 });
        }

        ThreadPool {

            sender,

            workers,

        }

    }

    /// Runs a FnOnce() with the number of threads it has.
    /// 
    /// # Examples
    /// 
    /// ```
    /// let pool = ThreadPool::new();
    /// ```
    pub fn execute<F: FnOnce() + Send + 'static>(&self, job: F) {
        self.sender.send(Message::Job(Box::new(job))).unwrap();
    }

    pub fn shutdown(&mut self) {
        for _ in &self.workers {
            self.sender.send(Message::Terminate).unwrap();
        }

        println!("ThreadPool 1.0.1: Shutting down all threads.");

        for worker in &mut self.workers {
            println!("ThreadPool 1.0.1: Shutting down worker {}", worker.id);

            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }
        }
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        self.shutdown();
    }
}