use std::marker::PhantomData;
use std::sync::mpsc::{Sender as MpscSender, channel as mpsc_channel};
use std::thread::{Builder as ThreadBuilder, JoinHandle as ThreadJoinHandle};

pub struct Work<UserData: Send + Sync + 'static>
{
    pub func: fn(UserData),
    pub user_data: UserData,
}

#[derive(Debug)]
pub struct WorkQueue<UserData: Send + Sync + 'static>
{
    work_sender: MpscSender<Work<UserData>>,
    _thread: ThreadJoinHandle<()>,
    _pd: PhantomData<UserData>,
}

impl<UserData: Send + Sync + 'static> WorkQueue<UserData>
{
    pub fn new(name: &str) -> Self
    {
        let (work_sender, work_receiver) = mpsc_channel::<Work<UserData>>();

        Self {
            work_sender,
            _thread: ThreadBuilder::new()
                .name(name.to_string())
                .spawn(move || {
                    let work_receiver = work_receiver;

                    while let Ok(work) = work_receiver.recv() {
                        (work.func)(work.user_data);
                    }
                })
                .expect("Failed to create work queue thread"),
            _pd: PhantomData,
        }
    }

    pub fn add_work(&self, work: Work<UserData>)
    {
        if self.work_sender.send(work).is_err() {
            tracing::error!("Cannot add work to work queue. Work queue thread is dead");
        }
    }
}