use crate::{session2::SessionMessage, Request};
use std::{
    sync::mpsc::{channel, Receiver, Sender},
    thread::spawn,
};

#[derive(Clone)]
pub enum Message {
    Register(Sender<Message>),
    Req(Request),
    SessMsg(SessionMessage),
}

impl From<Request> for Message {
    fn from(value: Request) -> Self {
        Message::Req(value)
    }
}

impl From<Sender<Message>> for Message {
    fn from(value: Sender<Message>) -> Self {
        Message::Register(value)
    }
}

impl From<SessionMessage> for Message {
    fn from(value: SessionMessage) -> Self {
        Message::SessMsg(value)
    }
}

#[cfg(test)]
mod messages {
    use super::*;
    use crate::{create_request::empty_request, Field};

    #[test]
    fn from_request() {
        let (req, _) = empty_request();
        match req.into() {
            Message::Req(result) => assert!(result.get_session().is_none()),
            _ => unreachable!("should have been s request"),
        }
    }

    #[test]
    fn from_sender() {
        let (tx, rx) = channel();
        match tx.into() {
            Message::Register(result) => {
                let (req, _) = empty_request();
                result.send(req.into()).unwrap();
                match rx.recv().unwrap() {
                    Message::Req(_) => {}
                    _ => unreachable!("should have been a request"),
                }
            }
            _ => unreachable!("should have been a register"),
        }
    }

    #[test]
    fn from_sessionmessage() {
        let id: Option<Field> = None;
        let sess_msg: SessionMessage = id.into();
        match sess_msg.into() {
            Message::SessMsg(result) => match result {
                SessionMessage::Validate(data) => assert!(data.is_none()),
                _ => unreachable!("should have been a validate"),
            },
            _ => unreachable!("should have been a session message"),
        }
    }
}

struct Queue {
    channels: Vec<Sender<Message>>,
    rx: Receiver<Message>,
}

impl Queue {
    fn new(rx: Receiver<Message>) -> Self {
        Self {
            channels: Vec::new(),
            rx: rx,
        }
    }

    fn listen(&mut self) {
        loop {
            let msg = self.rx.recv().unwrap();
            match msg {
                Message::Register(tx) => self.channels.push(tx),
                _ => {
                    for tx in self.channels.iter() {
                        tx.send(msg.clone()).unwrap();
                    }
                }
            }
        }
    }

    fn start() -> Sender<Message> {
        let (tx, rx) = channel();
        spawn(move || {
            let mut queue = Queue::new(rx);
            queue.listen();
        });
        tx
    }
}

#[cfg(test)]
mod queues {
    use super::*;
    use crate::create_request::empty_request;

    #[test]
    fn create_queue() {
        let mut channels = Vec::new();
        for _ in 0..5 {
            channels.push(channel());
        }
        let mut queue_tx = Queue::start();
        for (tx, _) in channels.iter() {
            queue_tx.send(tx.clone().into()).unwrap();
        }
        let (req, _) = empty_request();
        queue_tx.send(req.into()).unwrap();
        for (_, rx) in channels.iter() {
            match rx.recv().unwrap() {
                Message::Req(_) => {}
                _ => unreachable!("should have been a request"),
            }
        }
    }
}