use super::super::super::model::state::room::Room;
use super::lobby::Lobby;

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> {
      println!(". run lobby");
      loop {
         let rollback = self.room.since();
         let events = self.room.sync();
         println!(". rollback: {:?}", rollback);
         for e in &events {
            println!("e: {:?}", e);
         }
         self.room.rollback(rollback);
         break
      }
      Err("not impl".to_string())
   }

   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()));
      println!("made");
   }

   #[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 mut r1 = mrs.create();
      let room_id = r1.room_id();
      let mut gm = GameMaster::new(r1);
      let mut r2 = mrs.join(room_id).unwrap();
      gm.run_lobby();
      assert!(gm.lobby.players.len() == 1, "players: {:?}, sync: {:?}", gm.lobby.players, gm.room.sync());
   }

   #[test]
   fn run_game_setup_fail() {
      let gm = GameMaster::new(Box::new(MockRoom::create()));
      panic!("not impl");
   }

   #[test]
   fn run_game_fail() {
      let gm = GameMaster::new(Box::new(MockRoom::create()));
      panic!("not impl");
   }
}