use super::{Message, Msg, MsgData};
use std::{
    fmt,
    sync::mpsc::{channel, Receiver, Sender},
    thread::spawn,
};
use uuid::Uuid;

#[derive(Clone)]
pub enum SessionMsg {
    Get(Option<String>),
    Opened(SessionData),
}

impl Msg for SessionMsg {
    fn to_msgdata(&self) -> MsgData {
        MsgData::Session(self.clone())
    }
}

#[derive(Clone)]
pub struct SessionData {
    id: Uuid,
}

impl SessionData {
    pub fn new(id: Uuid) -> Self {
        Self { id: id }
    }
}

impl fmt::Display for SessionData {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.id)
    }
}

pub struct Session {
    router_tx: Sender<Message>,
    session_rx: Receiver<Message>,
    ids: Vec<Uuid>,
}

impl Session {
    fn new(router_tx: Sender<Message>, session_rx: Receiver<Message>) -> Self {
        Self {
            router_tx: router_tx,
            session_rx: session_rx,
            ids: Vec::new(),
        }
    }

    pub fn start(router_tx: Sender<Message>) -> Sender<Message> {
        let (session_tx, session_rx) = channel();
        spawn(move || {
            let mut session = Session::new(router_tx, session_rx);
            session.listen();
        });
        session_tx
    }

    fn listen(&mut self) {
        loop {
            let msg = self.session_rx.recv().unwrap();
            match msg.get_message() {
                MsgData::Session(data) => match data {
                    SessionMsg::Get(req_id) => {
                        let id: Uuid;
                        match req_id {
                            Some(req) => {
                                match Uuid::try_parse(req) {
                                    Ok(data) => {
                                        if self.ids.contains(&data) {
                                            id = data;
                                        } else {
                                            id = self.create_session();
                                        }
                                    },
                                    Err(_) => id = self.create_session(),
                                }
                            },
                            None => id = self.create_session(),
                        }
                        let data = SessionMsg::Opened(SessionData::new(id));
                        self.router_tx.send(msg.reply(&data)).unwrap()
                    },
                    _ => {}
                },
                _ => {}
            }
        }
    }

    fn create_session(&mut self) -> Uuid {
        let id = Uuid::new_v4();
        self.ids.push(id.clone());
        id
    }
}

#[cfg(test)]
mod messages {
    use super::{super::test_message::Tester, *};
    use std::time::Duration;

    fn setup_session() -> (Sender<Message>, Receiver<Message>) {
        let (tx, rx) = channel();
        let session_tx = Session::start(tx);
        (session_tx, rx)
    }

    #[test]
    fn ignore_unwanted_messages() {
        let (tx, rx) = setup_session();
        let data = Tester::Test1;
        let msg = Message::new(&data);
        tx.send(msg).unwrap();
        match rx.recv_timeout(Duration::from_millis(500)) {
            Err(_) => {}
            _ => unreachable!("Should not receive anything."),
        }
    }

    #[test]
    fn create_new_session() {
        let (tx, rx) = setup_session();
        let msgdata = SessionMsg::Get(None);
        let msg = Message::new(&msgdata);
        tx.send(msg.clone()).unwrap();
        let result = rx.recv().unwrap();
        assert_eq!(result.get_id(), msg.get_id());
        match result.get_message() {
            MsgData::Session(data) => match data {
                SessionMsg::Opened(_) => {}
                _ => unreachable!("Should have been an opened response."),
            },
            _ => unreachable!("Should be a session responsee."),
        }
    }

    #[test]
    fn ignore_session_replies() {
        let (tx, rx) = setup_session();
        let msgdata = SessionMsg::Opened(SessionData::new(Uuid::new_v4()));
        let msg = Message::new(&msgdata);
        tx.send(msg).unwrap();
        match rx.recv_timeout(Duration::from_millis(500)) {
            Err(_) => {}
            _ => unreachable!("Should not receive anything."),
        }
    }

    #[test]
    fn ids_must_be_unique() {
        let (tx, rx) = setup_session();
        let msgdata = SessionMsg::Get(None);
        let mut ids: Vec<String> = Vec::new();
        for _ in 0..10 {
            let msg = Message::new(&msgdata);
            tx.send(msg).unwrap();
            match rx.recv().unwrap().get_message() {
                MsgData::Session(msg) => match msg {
                    SessionMsg::Opened(sess) => {
                        let id = sess.to_string();
                        assert!(!ids.contains(&id), "duplicated id found.");
                        ids.push(id);
                    }
                    _ => unreachable!("Shouuld have opened a session."),
                },
                _ => unreachable!("Should be a session message"),
            }
        }
    }

    #[test]
    fn expired_ids_get_new() {
        let (tx, rx) = setup_session();
        let old_id = Uuid::new_v4();
        let msgdata = SessionMsg::Get(Some(old_id.to_string()));
        let msg = Message::new(&msgdata);
        tx.send(msg.clone()).unwrap();
        let result = rx.recv().unwrap();
        assert_eq!(result.get_id(), msg.get_id());
        match result.get_message() {
            MsgData::Session(msg) => match msg {
                SessionMsg::Opened(sess) => assert_ne!(sess.to_string(), old_id.to_string()),
                _ => unreachable!("Should habe been an Opened message."),
            },
            _ => unreachable!("Should have been a session message."),
        }
    }

    #[test]
    fn bad_session_ids_get_new() {
        let (tx, rx) = setup_session();
        let id = "something badA";
        let msgdata = SessionMsg::Get(Some(id.to_string()));
        let msg = Message::new(&msgdata);
        tx.send(msg.clone()).unwrap();
        let result = rx.recv().unwrap();
        assert_eq!(result.get_id(), msg.get_id());
        match result.get_message() {
            MsgData::Session(data) => match data {
                SessionMsg::Opened(sess) => assert_ne!(sess.to_string(), id),
                _ => unreachable!("Should habe been an Opened message."),
            },
            _ => unreachable!("Should have been a session message."),
        }
    }

    #[test]
    fn uses_existing_session() {
        let (tx, rx) = setup_session();
        let msgdata = SessionMsg::Get(None);
        let msg = Message::new(&msgdata);
        tx.send(msg).unwrap();
        let result = rx.recv().unwrap();
        let thesess = match result.get_message() {
            MsgData::Session(data) => match data {
                SessionMsg::Opened(sess) => sess,
                _ => unreachable!("Should habe been an Opened message."),
            },
            _ => unreachable!("Should have been a session message."),
        };
        let msgdata = SessionMsg::Get(Some(thesess.to_string()));
        let msg = Message::new(&msgdata);
        tx.send(msg.clone()).unwrap();
        let result = rx.recv().unwrap();
        assert_eq!(result.get_id(), msg.get_id());
        match result.get_message() {
            MsgData::Session(data) => match data {
                SessionMsg::Opened(sess) => assert_eq!(sess.to_string(), thesess.to_string(), "Should use existing sesssion."),
                _ => unreachable!("Should habe been an Opened message."),
            },
            _ => unreachable!("Should have been a session message."),
        }
    }
}