use super::rooms::Rooms;
use super::room::Room;
use super::mockroom::MockRoom;
use super::mockroom::rands;

// #[derive(Clone, Debug)]
pub struct MockRooms {
   rooms: Vec<MockRoom>,
}

impl MockRooms {
   pub fn new() -> MockRooms {
      MockRooms {
         rooms: vec![],
      }
   }
}

impl Rooms for MockRooms {
   fn create(&mut self) -> Box<dyn Room> {
      let room = MockRoom::create();
      let _room = room.room();
      self.rooms.push(room);
      Box::new(_room)
   }

   fn join(&self, room_id: String) -> Result<Box<dyn Room>, &str> {
      for r in &self.rooms {
         if r.room_id() == room_id {
            let mut r = r.room();
            r.send(format!(r#"{{
               "displayname": "{}",
               "membership": "join"
            }}"#, rands()));
            return Ok(Box::new(r));
         }
      }
      Err("not found")
   }
}

#[cfg(test)]
mod tests {
   use super::MockRooms;
   use super::MockRoom;
   use super::Rooms;

   fn _dummy() -> MockRooms {
      let mut mrs = MockRooms::new();
      for i in 0..5 {
         let random = MockRoom::create();
         mrs.rooms.push(random);
         let joined = MockRoom::join(i.to_string());
         mrs.rooms.push(joined);
      }
      assert!(mrs.rooms.len() == 10);
      mrs
   }

   #[test]
   fn mockrooms() {
      let mrs = MockRooms::new();
      assert!(mrs.rooms.len() == 0);
   }

   #[test]
   fn create() {
      let mut mrs = _dummy();
      let was = mrs.rooms.len();
      let _ = mrs.create();
      let is = mrs.rooms.len();
      assert!(was+1 == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
   }

   #[test]
   fn join_404() {
      let mrs = _dummy();
      let was = mrs.rooms.len();
      let r = mrs.join("does not exist".to_string());
      let is = mrs.rooms.len();
      assert!(was == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
      assert!(!r.is_ok());
   }

   #[test]
   fn join_found() {
      let mrs = _dummy();
      let was = mrs.rooms.len();
      let r = mrs.join("0".to_string());
      let is = mrs.rooms.len();
      assert!(was == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
      assert!(r.is_ok());
      assert!(r.ok().unwrap().room_id() == "0");
   }

   #[test]
   fn join_clobber() {
      let mrs = _dummy();
      let mut a = mrs.join("0".to_string()).ok().unwrap();
      let mut b = mrs.join("0".to_string()).ok().unwrap();
      assert!(a.room_id() == b.room_id());
      assert!(a.sync().len() == b.sync().len());
      assert!(a.sync().len() == b.sync().len());
      assert!(a.sync().len() == 0);
      assert!(b.sync().len() == 0);
      assert!(a.send("from a".to_string()).is_ok());
      assert!(a.sync().len() == 1);
      assert!(b.sync().len() == 1);
      assert!(b.send("from b".to_string()).is_ok());
      assert!(b.send("from b".to_string()).is_ok());
      assert!(a.sync().len() == 2);
      assert!(b.sync().len() == 2);
      assert!(a.send("from a".to_string()).is_ok());
      assert!(b.send("from b".to_string()).is_ok());
      assert!(a.send("from a".to_string()).is_ok());
      assert!(a.sync().len() == 3);
      assert!(b.sync().len() == 3);
      assert!(a.send("from a".to_string()).is_ok());
      assert!(b.send("from b".to_string()).is_ok());
      let a = a.sync();
      let b = b.sync();
      assert!(a.len() == 2);
      assert!(b.len() == 2);
      assert!(a[0].body == "from a");
      assert!(b[0].body == "from a");
      assert!(a[1].body == "from b");
      assert!(b[1].body == "from b");
   }
}