use json;

#[derive(Clone, Debug)]
pub struct Event {
   pub sender: String,
   pub body: String,
   pub next: String,
}

#[derive(PartialEq, Eq, Debug)]
pub enum EventType {
   Null,
   Join,
   Create,
   Message,
}

impl Event {
   pub fn mode(&self) -> EventType {
      let d = json::parse(&self.body).unwrap();
      if d["membership"].is_string() {
         return match d["membership"].as_str().unwrap().to_string().as_ref() {
            "join" => EventType::Join,
            _ => EventType::Null,
         };
      }
      if d["creator"].is_string() {
         return EventType::Create;
      }
      if d["msgtype"].is_string() {
         return match d["msgtype"].as_str().unwrap().to_string().as_ref() {
            "m.text" => EventType::Message,
            _ => EventType::Null,
         };
      }
      EventType::Null
   }

   pub fn join(&self) -> Option<String> {
      let d = json::parse(&self.body).unwrap();
      match self.mode() {
         EventType::Join => true,
         _ => return None,
      };
      let o = d["displayname"].as_str();
      if o.is_none() {
         return None;
      }
      Some(o.unwrap().to_string())
   }
}

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

   fn _dummy() -> Event {
      Event{
         sender: "sender".to_string(),
         body: r#"{}"#.to_string(),
         next: "next".to_string(),
      }
   }

   #[test]
   fn event() {
      let e = Event{
         sender: "sender".to_string(),
         body: "body".to_string(),
         next: "next".to_string(),
      };
      println!("{:?}", e);
   }

   #[test]
   fn mode_null() {
      let mut e = _dummy();
      e.body = r#"{
      }"#.to_string();
      assert!(e.mode() == EventType::Null);
   }

   #[test]
   fn mode_create() {
      let mut e = _dummy();
      e.body = r#"{
         "creator": "abc"
      }"#.to_string();
      assert!(e.mode() == EventType::Create);
   }

   #[test]
   fn mode_msgtype() {
      let mut e = _dummy();
      e.body = r#"{
         "msgtype": "m.text"
      }"#.to_string();
      assert!(e.mode() == EventType::Message);
   }

   #[test]
   fn mode_join() {
      let mut e = _dummy();
      e.body = r#"{
         "membership": "join"
      }"#.to_string();
      assert!(e.mode() == EventType::Join);
   }

   #[test]
   fn join_some() {
      let mut e = _dummy();
      e.body = r#"{
         "displayname": "hi",
         "membership": "join"
      }"#.to_string();
      let j = e.join();
      assert!(j.is_some());
   }

   #[test]
   fn join_some_bad() {
      let mut e = _dummy();
      e.body = r#"{
         "membership": "join"
      }"#.to_string();
      let j = e.join();
      assert!(j.is_none());
   }

   #[test]
   fn join_none() {
      let mut e = _dummy();
      e.body = r#"{
         "a": "b"
      }"#.to_string();
      let j = e.join();
      assert!(j.is_none());
   }
}