// START LICENSE
   // JSet - a Java JSet card board game implementation
   // Copyright (C) 2004 Jerome Lacoste
   //
   // This program is free software; you can redistribute it and/or modify
   // it under the terms of the GNU General Public License as published by
   // the Free Software Foundation; either version 2 of the License, or (at
   // your option) any later version.
   //
  // This program is distributed in the hope that it will be useful, but
  // WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  // General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program; if not, write to the Free Software
  // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  // END LICENSE
  
  package org.cb.jset.client;
  
  import org.cb.jset.CardSet;
  import org.cb.jset.MatchingException;
  import org.cb.jset.CardProperties;
  import org.cb.jset.server.RemoteSetGame;
  import org.cb.jset.server.RemoteSetGamePlayer;
  import org.cb.jset.server.RemoteSetGameConnection;
  
  import org.apache.log4j.Logger;
  
  import java.rmi.RemoteException;
  import java.rmi.NoSuchObjectException;
  import java.rmi.server.UnicastRemoteObject;
  import java.io.Serializable;
  
  /***
   * FIXME document
   *
   * @author jerome@coffeebreaks.org - last modified by $LastModifiedBy$
   * @version $Id: NetworkGame.java 129 2004-04-15 05:00:43Z jerome $
   */
  public class NetworkGame extends AbstractGame
  {
    private Logger _logger = Logger.getLogger(NetworkGame.class);
  
    private RemoteSetGame _remoteGame;
    private PlayerRemoteGame _playerRemoteGame;
    private RemoteSetGameConnection _gameConnection;
    private final String _clientName;
  
    private boolean _wasDisconnected;
  
    public NetworkGame(final String clientName)
    {
      _clientName = clientName;
    }
  
    static class PlayerRemoteGame implements RemoteSetGamePlayer, Serializable
    {
      private final transient Logger _logger = Logger.getLogger(PlayerRemoteGame.class);
      private boolean _isBlocked;
      private final String _clientName;
      private transient final NetworkGame _game;
  
      public PlayerRemoteGame(final NetworkGame game, final String clientName)
      {
        _game = game;
        _clientName = clientName;
      }
  
      public String getName() throws RemoteException
      {
        return _clientName;
      }
  
      public void block() throws RemoteException
      {
        _isBlocked = true;
        // FIXME forward events?
      }
  
      public void unblock() throws RemoteException
      {
        _isBlocked = false;
        // FIXME forward events?
      }
  
      public boolean isBlocked() throws RemoteException
      {
        return _isBlocked;  //To change body of implemented methods use File | Settings | File Templates.
      }
  
      public void disconnect() throws RemoteException
      {
        _game.setWasDisconnected(true);
      }
  
      public void cardsAdded(final CardProperties[] cards) throws RemoteException
      {
       _logger.debug("Cards Added " + CardProperties.toString(cards));
       _game.fireCardsAdded(cards);
     }
 
     public void setRemoved(final CardSet set) throws RemoteException
     {
       _logger.debug("Set removed " + set);
       _game.fireSetRemoved(set);
     }
 
     void registerClient()
         throws RemoteException
     {
       UnicastRemoteObject.exportObject(this);
     }
 
     private void unregisterClient()
         throws NoSuchObjectException
     {
       final boolean lUnexported = UnicastRemoteObject.unexportObject(this, false);
       if (!lUnexported)
       {
         _logger.warn("Failure to unexport. Calls pending!! trying to force");
         final boolean lUnexportedSecondTry = UnicastRemoteObject.unexportObject(this, true);
         _logger.info("Managed to disconnect? " + lUnexportedSecondTry);
       }
     }
 
   }
 
   public void setRemoteGame(final RemoteSetGame remoteGame)
   {
     _remoteGame = remoteGame;
   }
 
   public void start()
   {
     _playerRemoteGame = new PlayerRemoteGame(this, _clientName);
     final GameThread thread = new GameThread();
     // FIXME do we want this?
     // thread.setDaemon(true);
     thread.start();
   }
 
 
   private void connect() throws RemoteException
   {
     _gameConnection = _remoteGame.connect(_playerRemoteGame);
   }
 
 
   public synchronized void setWasDisconnected(final boolean wasDisconnected)
   {
     _wasDisconnected = wasDisconnected;
     notifyAll();
   }
 
   public synchronized boolean wasDisconnected()
   {
     return _wasDisconnected;
   }
 
   public void stop()
   {
     try
     {
       _gameConnection.close();
     }
     catch (RemoteException e)
     {
       _logger.debug("Failure to stop game " + e.getMessage(), e);
       setWasDisconnected(true);
     }
   }
 
   public void endTurn()
   {
     // FIXME unused
   }
 
   public void removeSet(final CardSet set) throws MatchingException
   {
     try
     {
       _gameConnection.matchSet(set);
     }
     catch (RemoteException e)
     {
       _logger.debug("Failure to remove set " + e.getMessage(), e);
       setWasDisconnected(true);
     }
   }
 
 
   private void forceCloseConnection()
   {
     try
     {
       //	    if (! _connection.isClosed()) {
       if (_gameConnection != null && !this.wasDisconnected())
       {
         if (_logger.isInfoEnabled())
         {
           _logger.info("May have caught a CTRL-C");
         }
         _gameConnection.close();
       }
     }
     catch (RemoteException e)
     {
       _logger.error("Communication problem while closing.", e);
     }
   }
 
   void play() throws RemoteException
   {
 //        int oldCounter = _counter;
     if (_logger.isInfoEnabled())
     {
       _logger.info("-- starting to play --");
     }
     while (! (_gameConnection.isClosed() && this.wasDisconnected()))
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("-- wait for cards to be added --");
       }
       synchronized (this)
       {
         try
         {
           this.wait();
         }
         catch (InterruptedException e)
         {
         }
       }
     }
     if (_logger.isInfoEnabled())
     {
       _logger.info("-- player dying --");
     }
   }
 
   void addShutdownHook()
   {
     Runtime.getRuntime().addShutdownHook(new Thread()
     {
       public void run()
       {
         forceCloseConnection();
       }
     });
   }
 
   private class GameThread extends Thread
   {
     public void run()
     {
       addShutdownHook();
       try
       {
         registerClient();
         try
         {
           connect();
           play();
         }
         catch (RemoteException e)
         {
           _logger.error("Communication error in run().", e);
         }
         finally
         {
           unregisterClient();
         }
       }
       catch (RemoteException e)
       {
         _logger.error("Couldn't export Client object properly.", e);
       }
       finally
       {
         // FIXME reestablish
 //          _eventHandler.fireGameEvent(new GameEvent(GameEvent.END));
         _gameConnection = null;
       }
       if (_logger.isInfoEnabled())
       {
         _logger.info("player ending...");
       }
     }
 
     private void registerClient()
         throws RemoteException
     {
       UnicastRemoteObject.exportObject(_playerRemoteGame);
     }
 
     private void unregisterClient()
         throws NoSuchObjectException
     {
       final boolean lUnexported = UnicastRemoteObject.unexportObject(_playerRemoteGame, false);
       if (!lUnexported)
       {
         _logger.warn("Failure to unexport. Calls pending!! trying to force");
         final boolean lUnexportedSecondTry = UnicastRemoteObject.unexportObject(_playerRemoteGame, true);
         _logger.info("Managed to disconnect? " + lUnexportedSecondTry);
       }
     }
   }
 }