use super::room::Room;
use super::event::Event;

use rand::{self, Rng};
use rand::distributions::Alphanumeric;
use crossbeam_channel::{unbounded, Sender, Receiver};

#[derive(Clone, Debug)]
pub struct MockRoom {
   last: String,
   room_id: String,
   events_s: Sender<Vec<Event>>,
   events_r: Receiver<Vec<Event>>,
}

impl MockRoom {
   pub fn create() -> MockRoom {
      MockRoom::join(rands()) 
   }

   pub fn join(room_id: String) -> MockRoom {
      let (s, r) = unbounded();
      s.send(vec![]).ok().unwrap();
      MockRoom {
         last: "".to_string(),
         room_id: room_id,
         events_s: s,
         events_r: r,
      }
   }

   pub fn room(&self) -> impl Room {
      self.clone()
   }
}

impl Room for MockRoom {
   fn sync(&mut self) -> Vec<Event> {
      let mut unseen: Vec<Event> = vec![];
      let mut last = self.last.clone();
      let events = self.events_r.recv().ok().unwrap();
      for e in &events {
         if e.next == self.last {
            unseen.clear();
         } else {
            unseen.push(e.clone());
            last = e.next.clone();
         }
      }
      self.events_s.send(events).ok().unwrap();
      self.last = last;
      return unseen;
   }

   fn send(&mut self, message: String) -> Result<&str, &str> {
      let e = Event{
         sender: rands(),
         next: rands(),
         body: message,
      };
      let mut events = self.events_r.recv().ok().unwrap();
      events.push(e);
      self.events_s.send(events).ok().unwrap();
      Ok("ok")
   }

   fn room_id(&self) -> String {
      self.room_id.clone()
   }
}

impl Drop for MockRoom {
   fn drop(&mut self) {
      println!("MockRoom::drop not impl");
   }
}

pub fn rands() -> String {
   rand::thread_rng()
      .sample_iter(&Alphanumeric)
      .take(10)
      .collect::<String>()
}

#[cfg(test)]
mod tests {
   use super::Room;
   use super::MockRoom;
   use super::Event;
   use super::rands;

   fn _dummy() -> MockRoom {
      let mut r = MockRoom::create();
      r.last = "1".to_string();
      let mut events = r.events_r.recv().ok().unwrap();
      for i in 0..5 {
         events.push(Event{
            sender: i.to_string(), 
            next: i.to_string(), 
            body: i.to_string(),
         });
      }
      r.events_s.send(events).ok().unwrap();
      r
   }

   #[test]
   fn randstest() {
      let a = rands();
      let b = rands();
      assert!(a != b, "a == {} == b == {}", a, b);
   }

   #[test]
   fn create() {
      let mut r: MockRoom = MockRoom::create();
      println!("{:?}", r.sync());
   }

   #[test]
   fn join() {
      let rid = "a".to_string();
      let r: MockRoom = MockRoom::join(rid.to_string());
      assert!(r.room_id == rid);
   }

   #[test]
   fn sync() {
      let mut r = _dummy();
      let events = r.sync();
      assert!(events.len() == 3, "want {}, got {}: {:?}", 3, events.len(), events);
      assert!(events[0].sender == "2");
      assert!(events[0].body == "2");
      assert!(events[0].next == "2");
      assert!(r.last == "4", "want last==4, got {}", r.last);
   }

   #[test]
   fn send() {
      let mut r = _dummy();
      let message = "message".to_string();
      r.sync();
      assert!(r.send(message.clone()).ok().unwrap() == "ok");
      assert!(r.last == "4");
      let events = r.sync();
      assert!(events.len() == 1);
      assert!(events[0].body == message, "want {}, got {}: {:?}", message, events[0].body, events);
      assert!(r.last != "4");
   }
}