use super::{ClientMsg, Msg, SessionMsg};
use uuid::Uuid;

/// Message Types
#[derive(Clone)]
pub enum MsgData {
    Client(ClientMsg),
    Session(SessionMsg),
    Test1,
    Test2,
}

/// MoreThanText Message Structure
#[derive(Clone)]
pub struct Message {
    id: Uuid,
    msg: MsgData,
}

impl Message {
    pub fn new<D>(data: &D) -> Self
    where
        D: Msg,
    {
        Self {
            id: Uuid::new_v4(),
            msg: data.to_msgdata(),
        }
    }

    pub fn get_message(&self) -> &MsgData {
        &self.msg
    }

    pub fn get_id(&self) -> Uuid {
        self.id.clone()
    }

    pub fn reply<D>(&self, data: &D) -> Self
    where
        D: Msg,
    {
        Self {
            id: self.id.clone(),
            msg: data.to_msgdata(),
        }
    }
}

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

    #[test]
    fn new_messagees() {
        let data = Tester::Test1;
        let msg = Message::new(&data);
        match msg.get_message() {
            MsgData::Test1 => {}
            _ => unreachable!("Should have received Test1"),
        }
        let data = Tester::Test2;
        let msg = Message::new(&data);
        match msg.get_message() {
            MsgData::Test2 => {}
            _ => unreachable!("Should have received Test1"),
        }
    }

    #[test]
    fn message_ids_are_unique() {
        let mut ids: Vec<Uuid> = Vec::new();
        let data = Tester::Test1;
        for _ in 1..10 {
            let msg = Message::new(&data);
            assert!(!ids.contains(&msg.get_id()), "Had a duplicate id");
            ids.push(msg.get_id());
        }
    }

    #[test]
    fn create_replies() {
        let data1 = Tester::Test1;
        let data2 = Tester::Test2;
        let msg = Message::new(&data1);
        let reply = msg.reply(&data2);
        assert_eq!(reply.get_id(), msg.get_id());
        match reply.get_message() {
            MsgData::Test2 => {}
            _ => unreachable!("Should have been a Test1"),
        }
    }
}