use crate::{
    field::Field,
    queue::{Message, QueueClient},
};
use std::sync::mpsc::{Receiver, Sender};

#[derive(Debug)]
pub struct Document {
    session: Field,
    content: Field,
}

impl Document {
    pub fn new(session: Field, content: Field) -> Self {
        Self {
            session: session,
            content: content,
        }
    }

    /// Get the session id information.
    pub fn get_session(&self) -> String {
        self.session.to_string()
    }

    /// Get the requested content.
    pub fn get_content(&self) -> String {
        self.content.to_string()
    }
}

#[cfg(test)]
mod documeents {
    use super::*;

    #[test]
    fn create_response() {
        let id = "something";
        let txt = "stuff";
        let res = Document::new(id.into(), txt.into());
        match res.session {
            Field::Static(data) => assert_eq!(data, id),
            _ => unreachable!("wrong field type"),
        }
        match res.content {
            Field::Static(data) => assert_eq!(data, txt),
            _ => unreachable!("wrong field type"),
        }
    }

    #[test]
    fn get_id_string() {
        let id = "id";
        let doc = "content";
        let reply = Document::new(id.into(), doc.into());
        assert_eq!(reply.get_session(), id);
        assert_eq!(reply.get_content(), doc);
    }

    #[test]
    fn get_id_content() {
        let id = "session";
        let doc = "stuff";
        let reply = Document::new(id.into(), doc.into());
        assert_eq!(reply.get_session(), id);
        assert_eq!(reply.get_content(), doc);
    }
}

pub struct DocumentBuilder {
    _tx: Sender<Message>,
    rx: Receiver<Message>,
}

impl QueueClient for DocumentBuilder {
    fn new(tx: Sender<Message>, rx: Receiver<Message>) -> Self {
        Self {
            _tx: tx,
            rx: rx,
        }
    }

    fn get_receiver(&self) -> &Receiver<Message> {
        &self.rx
    }

    fn listen(&self) {
        let rx = self.get_receiver();
        loop {
            match rx.recv().unwrap() {
                Message::Req(data) => {
                    //data.get_sender().send(Document::new("id".into(), "stuff".into())).unwrap();
                    let doc = Document::new("id".into(), "stuff".into());
                    data.send(doc);
                },
                _ => {},
            }
        }
    }
}

#[cfg(test)]
mod builders {
    use crate::request_test_data::request_root_document;
    use std::sync::mpsc::{channel, TryRecvError};
    use super::*;

    fn run_service() -> (Sender<Message>, Receiver<Message>) {
        let (tx, rx) = channel();
        let service_tx: Sender<Message>;
        DocumentBuilder::start(tx);
        match rx.recv().unwrap() {
            Message::Register(result) => service_tx = result,
            _ => unreachable!("should register the service"),
        }
        (service_tx, rx)
    }

    #[test]
    fn get_document() {
        let (tx, rx) = run_service();
        let (msg, msg_rx) = request_root_document();
        tx.send(msg.into()).unwrap();
        match rx.try_recv() {
            Ok(_) => unreachable!("nothing should go back to the queue"),
            Err(err) => {
                match err {
                    TryRecvError::Empty => {},
                    _ => unreachable!("channel should still be open"),
                }
            },
        }
        msg_rx.recv().unwrap();
    }
}