/***
    * 
    */
   package pl.agh.iosr.ballamigos.webapp.core;
   
   import java.rmi.NoSuchObjectException;
   import java.rmi.NotBoundException;
   import java.rmi.RemoteException;
   import java.rmi.registry.LocateRegistry;
  import java.rmi.registry.Registry;
  import java.rmi.server.UnicastRemoteObject;
  import java.util.List;
  import java.util.Properties;
  
  import pl.agh.iosr.ballamigos.client.room.MatchesListModel;
  import pl.agh.iosr.ballamigos.common.Decision;
  import pl.agh.iosr.ballamigos.common.Match;
  import pl.agh.iosr.ballamigos.common.MatchProperties;
  import pl.agh.iosr.ballamigos.common.Player;
  import pl.agh.iosr.ballamigos.common.ServerStatistics;
  import pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface;
  import pl.agh.iosr.ballamigos.common.communication.rmi.ServerInterface;
  import pl.agh.iosr.ballamigos.common.exceptions.LoginException;
  import pl.agh.iosr.ballamigos.common.exceptions.MatchAlreadyExistsException;
  import pl.agh.iosr.ballamigos.common.exceptions.MatchDoesntExistException;
  import pl.agh.iosr.ballamigos.common.exceptions.MatchFullException;
  import pl.agh.iosr.ballamigos.common.exceptions.PlayerAlreadyExistsException;
  import pl.agh.iosr.ballamigos.common.exceptions.PlayerAlreadyInGameException;
  import pl.agh.iosr.ballamigos.common.exceptions.PlayerAlreadyLoggedException;
  
  /***
   * @author wrobel
   *
   */
  public class WebApplicationCommunicator implements ClientInterface {
  	private String playerLogin;
  	private String playerPassword;
  	private String roomName;
  	private Match match;
  	private boolean matchStartedFlag = false;
  	private boolean matchReceivedFlag = false;
  	private boolean playerEnteredFlag = false;
  	/***
  	 * List of matches
  	 */
  	private MatchesListModel matches;
  	
  	/***
  	 * list of all rooms names
  	 */
  	private List<String> roomNames;
  	
  	/***
  	 * remote server to comunicate with.
  	 */
  	private ServerInterface server;
  	
  	
  	/***
  	 * Constructor that tries to locate server via rmiregistry
  	 * @param serverName - inet addres of rmiregistry
  	 * @param port - port of rmiregistry
  	 * @throws RemoteException - can't connect to rmiregistry
  	 * @throws NotBoundException - there's no server bounded in rmiregistry
  	 */
  	public WebApplicationCommunicator(String serverName, int port) throws RemoteException, NotBoundException{
  		    Registry registry = LocateRegistry.getRegistry(serverName,port);
  		    server = (ServerInterface) registry.lookup("ServerBallAmigos");
  	}
  
  	 public WebApplicationCommunicator(Properties props) throws NumberFormatException, RemoteException, NotBoundException {		
           Registry registry = LocateRegistry.getRegistry(props.getProperty("Host"), Integer.parseInt(props.getProperty("Port")));
  		 server = (ServerInterface) registry.lookup("ServerBallAmigos");
  	 }
  
  	/***
  	 * tries to log to a server using login and password
  	 * @param login - player login.
  	 * @param passwd - player password.
  	 * @throws RemoteException - server connection failed
  	 * @throws PlayerAlreadyLoggedException - there is a player logged with this login.
  	 * @throws LoginException 
  	 */
  	public void login(String login, String passwd) throws RemoteException, PlayerAlreadyLoggedException, LoginException
  	{
  		try
  		{
  			UnicastRemoteObject.unexportObject(this,true);
  		}
  		catch(NoSuchObjectException e)
  		{
  			
  		}
  		UnicastRemoteObject.exportObject(this, 0);
  		server.loginPlayer(new Player(login,passwd), this);
  		this.roomNames = server.getRooms();
  		this.playerLogin = login;
  		this.playerPassword = passwd;
  		this.matches = new MatchesListModel();
 	}
 	
 	/***
 	 * 
 	 * @param login
 	 * @param passwd
 	 * @throws RemoteException
 	 */
 	public void createPlayer(String login, String passwd) throws RemoteException, PlayerAlreadyExistsException
 	{
 		server.createPlayer(login,passwd);
 	}
 	
 	/***
 	 * tells server to bind player to a room
 	 * @param roomName - name of the room that player wants to join
 	 * @throws RemoteException - server connection failed
 	 */
 	public void moveToRoom(String roomName) throws RemoteException
 	{
 		server.bindToRoom(playerLogin, roomName);
 		this.roomName = roomName;
 	}
 	
 	/***
 	 * requests list of players names in player room from server.
 	 * @return list of players names in players room
 	 * @throws RemoteException - server connection failed
 	 */
 	public List<String> getPlayersInRoom() throws RemoteException
 	{
 		return server.getPlayersInRoom(roomName);
 	}
 	
 	/* (non-Javadoc)
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#reciveMessage(java.lang.String)
 	 */
 	public void reciveMessage(String arg0) throws RemoteException {
 		return;
 
 	}
 
 	/* (non-Javadoc)
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#reciveMessage(java.lang.String, java.lang.String)
 	 */
 	public void reciveMessage(String arg0, String arg1) throws RemoteException {
 		return;
 	}
 
 	/* (non-Javadoc)
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#reciveMessage(java.lang.String, java.lang.String, java.lang.String)
 	 */
 	public void reciveMessage(String arg0, String arg1, String arg2)
 			throws RemoteException {
 		return;
 
 	}
 
 	/*** 
 	 * Used to notify client that a player has entered the room he is in.
 	 * @param playerName - name of player that entered room
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#playerEnteredRoom(java.lang.String)
 	 */
 	public void playerEnteredRoom(String playerName) throws RemoteException {
 		// TODO Auto-generated method stub
 
 	}
 
 
 	/*** 
 	 * Used to notify client that a player has left the room he is in.
 	 * @param playerName - name of player that left room
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#playerLeftRoom(java.lang.String)
 	 */
 	public void playerLeftRoom(String playerName)
 	{
 		// TODO Auto-generated method stub
 
 	}
 
 	/***
 	 * logs this player out of server.
 	 *
 	 */
 	public void logout() throws RemoteException
 	{
 		server.logout(playerLogin);
 	}
 	
 	/***
 	 * tries to create and register a match on the server
 	 * @param name - name of this match
 	 */
 	public void createMatch(String name) throws RemoteException, MatchAlreadyExistsException, PlayerAlreadyInGameException
 	{	
 		match = server.createMatch(name, playerLogin);
 		synchronized(this){
 			matchStartedFlag = false;
 		}
 	}
 	
 
 	/*** 
 	 * Notyfies that a macth in this room was created.
 	 * @param matchName - name match that was created.
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#matchCreated(java.lang.String)
 	 */
 	public void matchCreated(String matchName) throws RemoteException
 	{
 		this.matches.addMatch(matchName);
 	}
 
 	/*** 
 	 * Notyfies that a macth in this room was removed.
 	 * @param matchName - name match that was removed.
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#matchRemoved(java.lang.String)
 	 */
 	public void matchRemoved(String matchName) throws RemoteException {
 		this.matches.removeMatch(matchName);
 
 	}
 
 	/***
 	 * Joins match if posible. 
 	 * @param matchName - name of a match to join
 	 */
 	public void joinMatch(String matchName) throws RemoteException, MatchFullException, PlayerAlreadyInGameException 
 	{
 		match = server.joinMatch(matchName, playerLogin);
 	}
 	
 	/*** 
 	 * Implements playerJoins method. Used by server to notify clients when a player has joined their room.
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#playerJoins(java.lang.String)
 	 */
 	public synchronized void playerJoins(String playerName) throws RemoteException
 	{
 		playerEnteredFlag= true;
 		notify();
 	}
 
 	public void playerQuitedMatch()
 	{
 	
 	}
 	
 
 	public synchronized boolean matchReceived()
 	{
 		return matchReceivedFlag;
 	}
 	
 	/*** 
 	 * Implements reciveCurrentMatch method. Used by server to send results of their moves (current match state). It tells display panel to display animation a this move
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#reciveCurrentMatch(pl.agh.iosr.ballamigos.common.Match)
 	 */
 	public synchronized void reciveCurrentMatch(Match match) throws RemoteException
 	{
 		matchReceivedFlag= true;
 		this.match = match;
 		notify();
 	}
 
 	public synchronized boolean playerEntered()
 	{
 		return playerEnteredFlag;
 	}
 	/***
 	 * Check if current match is active
 	 * @return
 	 */
 	public synchronized boolean matchStarted()
 	{
 		return matchStartedFlag;
 	}
 	/*** 
 	 * Implements startMatch method. Tells client that match has started
 	 * @see pl.agh.iosr.ballamigos.common.communication.rmi.ClientInterface#startMatch()
 	 */
 	public synchronized void startMatch() throws RemoteException
 	{
 		matchStartedFlag = true;
 		notify();
 	}
 
 	/***
 	 * Sends a signal to server to start match, if succed start the match on this clienmt to.
 	 *
 	 */
 	public void sendStartMatch() throws RemoteException
 	{
 		server.startMatch(match.getMatchName(), playerLogin);
 	}
 	
 	/***
 	 * Change properties of current match
 	 * @param properties
 	 * @throws RemoteException
 	 */
 	public void changeMatchProperties(MatchProperties properties) throws RemoteException, MatchDoesntExistException
 	{
 		server.changeMatchProperties(playerLogin, match.getMatchName(), properties);
 		match.setProperties(properties);
 	}
 	
 	/***
 	 * Sends current player move decision.
 	 * @param decision - contains player choises for this round.
 	 */
 	public synchronized void sendDecision(Decision decision) throws RemoteException
 	{			
 		server.makeDecision(decision, playerLogin);
 		matchReceivedFlag = false;
 	}
 	
 	public List<String> getRoomNames() throws RemoteException {
 		return server.getRooms();
 	}
 
 	public ServerStatistics getServerStatistics() throws RemoteException {
 		return server.getServerStatistics();
 	}
 
 	/***
 	 * @return Returns the match.
 	 */
 	public Match getMatch() {
 		return match;
 	}
 
 	/***
 	 * @param match The match to set.
 	 */
 	public void setMatch(Match match) {
 		this.match = match;
 	}
 
 	/***
 	 * @return Returns the matches.
 	 */
 	public MatchesListModel getMatches() {
 		return matches;
 	}
 
 	/***
 	 * @param matches The matches to set.
 	 */
 	public void setMatches(MatchesListModel matches) {
 		this.matches = matches;
 	}
 
 	/***
 	 * @return Returns the playerLogin.
 	 */
 	public String getPlayerLogin() {
 		return playerLogin;
 	}
 
 	/***
 	 * @param playerLogin The playerLogin to set.
 	 */
 	public void setPlayerLogin(String playerLogin) {
 		this.playerLogin = playerLogin;
 	}
 
 	/***
 	 * @return Returns the roomName.
 	 */
 	public String getRoomName() {
 		return roomName;
 	}
 
 	/***
 	 * @param roomName The roomName to set.
 	 */
 	public void setRoomName(String roomName) {
 		this.roomName = roomName;
 	}
 
 	/***
 	 * @return Returns the server.
 	 */
 	public ServerInterface getServer() {
 		return server;
 	}
 
 	/***
 	 * @param server The server to set.
 	 */
 	public void setServer(ServerInterface server) {
 		this.server = server;
 	}
 
 	/***
 	 * @param roomNames The roomNames to set.
 	 */
 	public void setRoomNames(List<String> roomNames) {
 		this.roomNames = roomNames;
 	}
 	
 	/***Gets a list of matches for the chosen room.
 	 * 
 	 * @return Returns a list of matches in the current room
 	 * @throws RemoteException when there a problems with RMI
 	 */
 	public List<String> getMatchesInRoom() throws RemoteException
 	{
 		return server.getMatchesInRoom(roomName);
 	}
 	
 }