use super::super::super::model::state::room::Room;
use super::lobby::Lobby;
use super::gameevent::GameEvent;
use super::gameevent::GameEventType;
use std::thread;
use std::time;

pub struct GameMaster {
   room: Box<dyn Room>,
   lobby: Lobby,
}

impl GameMaster {
   fn new(room: Box<dyn Room>) -> GameMaster {
      GameMaster{
         room: room,
         lobby: Lobby::new(),
      }
   }

   fn run(&mut self) -> Result<String, String> {
      self.run_lobby()?;
      self.run_game_setup()?;
      self.run_game()
   }

   fn run_lobby(&mut self) -> Result<String, String> {
      while !self.lobby.locked {
         let rollback = self.room.since();
         let events = self.room.sync();
         println!("top of loop: since={:?}, events={:?}", self.room.since(), events);
         for e in &events {
            let ge = GameEvent::new(e.body.clone());
            println!("   ge.mode = {:?}", ge.mode());
            if ge.mode() == GameEventType::GameStart {
               println!("      should return");
               self.room.rollback(e.since.clone());
               self.lobby.lock();
               return Ok("ok".to_string());
            }
            self.lobby.eat(e.clone());
         }
         thread::sleep(time::Duration::new(1, 0));
      }
      Ok("ok".to_string()) // todo: on lobby too small, return err and do not lock
   }

   fn run_game_setup(&mut self) -> Result<String, String> {
      Err("not impl".to_string())
   }

   fn run_game(&mut self) -> Result<String, String> {
      Err("not impl".to_string())
   }
}

#[cfg(test)]
mod tests {
   use super::*;
   use super::super::super::super::model::state::mockroom::MockRoom;
   use super::super::super::super::model::state::mockrooms::MockRooms;
   use super::super::super::super::model::state::rooms::Rooms;

   #[test]
   fn new_mockroom() {
      let _ = GameMaster::new(Box::new(MockRoom::create()));
   }

   #[test]
   fn new_rooms_mockrooms() {
      fn get() -> impl Rooms {
         let mrs = MockRooms::new();
         mrs
      }
      let mut mrs = get();
      let r = mrs.create();
      let _ = GameMaster::new(r);
   }

   #[test]
   fn new_mockrooms() {
      let mut mrs = MockRooms::new();
      let r = mrs.create();
      let _ = GameMaster::new(r);
   }

   #[test]
   fn run_lobby() {
      let mut mrs = MockRooms::new();
      let r1 = mrs.create();
      let room_id = r1.room_id();
      let mut gm = GameMaster::new(r1);
      let mut r2 = mrs.join(room_id).unwrap();
      r2.send(format!(r#"{{
         "msgtype": "m.text",
         "body": "{{\"GameEventType\": \"GameStart\"}}"
      }}"#)).unwrap();   // TODO mark end of new players
      gm.run_lobby();   // todo assert is_ok
      assert!(gm.lobby.players.len() == 2, "first run_lobby players: {:?}, sync: {:?}", gm.lobby.players, gm.room.sync());
      let mut players1 = vec![];
      for k in gm.lobby.players.keys() {
         players1.push(k.clone());
      }
      gm.run_lobby();   // todo assert is_ok
      assert!(gm.lobby.players.len() == 2, "secnd run_lobby players: {:?}, sync: {:?}", gm.lobby.players, gm.room.sync());
      let players2 = gm.lobby.players.keys();
      assert!(format!("{:?}", players1) == format!("{:?}", players2));
   }

   #[test]
   fn run_game_setup_fail() {
      assert!(false, "not impl");
   }

   #[test]
   fn run_game_fail() {
      assert!(false, "not impl");
   }
}