// 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;
  
  import org.apache.log4j.Logger;
  import org.cb.util.Assert;
  
  import java.io.Serializable;
  import java.util.Timer;
  import java.util.TimerTask;
  
  /***
   * @author jerome@coffeebreaks.org - last modified by $LastChangedBy: jerome $
   * @version $Id: JSetGameImpl.java 129 2004-04-15 05:00:43Z jerome $
   */
  public class JSetGameImpl implements SetGame
  {
    private Logger _logger = Logger.getLogger(this.getClass().getName());
    private static int gameId = 0;
  
    private String _name;
    private int _id;
    private Players _players;
    private final CardStack _cardStack = new CardStack();
    private SetGameBoard _board = new BoardImpl();
  
    private GameThread _gameThread;
    private Timer _turnTimer;
    private boolean _endedTurn = false;
    private int _turnLengthInSeconds = 60 * 3;
  
    /***
     * Keeps track of the various connected players for that game.
     */
    class Players
    {
      private GameConnectionImpl[] _players;
      private int _nbPlayers;
  
      /***
       * Contructs an instance of Players, given the specified required number of playes.
       * @param nbPlayers the number of players for that game.
       */
      Players(final int nbPlayers)
      {
        _players = new GameConnectionImpl[nbPlayers];
        _nbPlayers = 0;
      }
  
      /***
       * @return the maximum number of players.
       */
      synchronized int getMaxNbPlayers()
      {
        return _players.length;
      }
  
      /***
       * @return the current number of registered players.
       */
      synchronized int getCurrentNbPlayers()
      {
        return _nbPlayers;
      }
  
      /***
       * Adds the specified player to the game.
       * @param player the player to add
       * @return the game connection related to that player.
       */
      synchronized GameConnectionImpl addPlayer(final SetGamePlayer player)
      {
        Assert.assertTrue(_nbPlayers < _players.length, "All players are already registered.");
  
        if (_logger.isInfoEnabled())
        {
          _logger.info("Players.addPlayer: current (" + _nbPlayers + " of " + _players.length + ")");
        }
        final GameConnectionImpl connection = new GameConnectionImpl(player);
        _players[_nbPlayers] = connection;
        _nbPlayers++;
        return connection;
     }
 
     /***
      * Removes the specified player from the game.
      * @param player the player to remove
      */
     synchronized void removePlayer(final SetGamePlayer player)
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("Players.removePlayer: current (" + _nbPlayers + " of " + _players.length + ")");
       }
       for (int i = 0; i < _players.length; i++)
       {
         final GameConnectionImpl gameConnection = _players[i];
         if (gameConnection != null)
         {
           if (gameConnection.getPlayer() == player)
           {
             // FIXME check that strange test
             if (!gameConnection.isClosed() && !(gameConnection.getPlayer() == null))
             {
               final String msg = "Implementation error: removing player while GC is non closed and/or gameConnection.getPlayer() not null";
               _logger.error(msg);
               throw new IllegalStateException(msg);
             }
             _players[i] = null;
             _nbPlayers--;
             return;
           }
         }
       }
       // not found?
     }
 
     /***
      * Fire a cards added event for all registered players.
      * @see SetGamePlayer#cardsAdded(org.cb.jset.CardProperties[])
      * @param cards the added cards
      */
     void fireAddedCardsEvent(final CardProperties[] cards)
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("Notifying players of added cards on board " + CardProperties.toString(cards));
       }
       for (int i = 0; i < _nbPlayers; i++)
       {
         Assert.assertTrue(_players[i] != null && _players[i].getPlayer() != null,
                           "Null player or null GameConnectionImpl");
         final SetGamePlayer player = _players[i].getPlayer();
         player.cardsAdded(cards);
       }
     }
 
     /***
      * Fire a set removed event for all registered players.
      * @see SetGamePlayer#setRemoved(org.cb.jset.CardSet)
      * @param set the removed set
      */
     void fireRemovedSetEvent(final CardSet set)
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("Notifying players of removed set from board" + CardProperties.toString(set.getCards()));
       }
       for (int i = 0; i < _nbPlayers; i++)
       {
         Assert.assertTrue(_players[i] != null && _players[i].getPlayer() != null,
                           "Null player or null GameConnectionImpl");
         final SetGamePlayer player = _players[i].getPlayer();
         player.setRemoved(set);
       }
 //      endTurn();  // FIXME - not exactly the spec...
     }
 
     /***
      * @return <code>true</code> if all expected players are connected.
      */
     synchronized boolean allConnected()
     {
       return _nbPlayers == _players.length;
     }
 
     /***
      * @return <code>true</code> if no players are connected.
      */
     synchronized boolean noneConnected()
     {
       return _nbPlayers == 0;
     }
 
     /***
      * Force the closing of the connections for all registered players.
      * @see GameConnectionImpl#internalClose()
      */
     synchronized void close()
     {
       // check that game is being closed?
 
       // note: going reverse on the _nbPlayers index, as it is being modified
       for (int i = _nbPlayers - 1; i >= 0; i--)
       {
         synchronized (_players[i])
         {
           if (!_players[i].isClosed())
           {
             _players[i].internalClose();
           }
           _nbPlayers--;
         }
       }
     }
   }
 
   /***
    * A GameConnectionImpl instance acts as a broker between a Player and the Game
    * Useful to keep track which player does what.
    * @todo we should probably turn this inner into a static inner class and make the reference
    * to the associated Game transient
    */
   public class GameConnectionImpl implements SetGameConnection, Serializable, Runnable
   {
     private transient SetGamePlayer _player;
     private boolean _isClosed = false;
     // FIXME we probably don't need threads in local connections...
     private Thread _me;
     private final transient Logger _logger;
 
     /***
      * Creates a new instance of GameConnectionImpl
      */
     public GameConnectionImpl(final SetGamePlayer player)
     {
       _logger = Logger.getLogger("GCon-" + player.getName());
       _player = player;
       _me = new Thread(this);
       init();
     }
 
     void init()
     {
       //            _me.start();
     }
 
     public void matchSet(final CardSet set) throws MatchingException
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info(getPlayer().getName() + " try to match a set: " + set);
       }
       try
       {
         removeMatchedSet(set);
       }
       catch (MatchingException e)
       {
         _logger.error("removeSet() failed: ", e);
         _logger.error("Blocking player");
         getPlayer().block();
         throw e;
       }
       catch(BoardException e)
       {
         _logger.error("removeSet() failed: ", e);
         _logger.error("Blocking player");
         getPlayer().block();
         throw new MatchingException(e.getMessage());
       }
     }
 
     SetGamePlayer getPlayer()
     {
       return _player;
     }
 
     // FIXME not clean: if called directly, _players doens't know about it
     // add a parameter: with call back.
     public void close()
     {
       internalClose();
       endGame();
     }
 
     void internalClose()
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("Closing connection for player - " + this);
       }
       // final Thread meTemp = _me;
       synchronized (this)
       {
         _me = null;
         _isClosed = true;
         notify();
       }
       /*
       while (meTemp.isAlive()) {
     try{
         _logger.info("Wait for thread to Die...");
         Thread.currentThread().sleep(500);
     } catch  (InterruptedException e) {}
       }
       */
 
       // FIXME we could avoid calling back those who asked for disconnection or encountered a failure.
       _logger.info("Trying to disconnect properly....");
       _player.disconnect();
       _logger.info("Disconnected properly....");
     }
 
     public synchronized boolean isClosed()
     {
       return _isClosed;
     }
 
     public void run()
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("Starting GameConnectionImpl thread");
       }
       final Thread thisThread = Thread.currentThread();
       while (_me == thisThread)
       {
         synchronized (this)
         {
           try
           {
             wait();
           }
           catch (InterruptedException e)
           {
             _logger.error("boum ", e);
           }
         }
       }
       if (_logger.isInfoEnabled())
       {
         _logger.info("Ending GameConnectionImpl thread");
       }
     }
   }
 
 
   public JSetGameImpl(final String name, final int nbPlayers)
   {
     _name = name;
     _players = new Players(nbPlayers);
     _id = gameId++;
     _gameThread = new GameThread();
 
     _board.addBoardListener(new SetGameBoardListener()
     {
       public void cardsAdded(final CardProperties[] cards)
       {
         notifyAddedCards(cards);
       }
 
       public void setRemoved(final CardSet set)
       {
         notifyRemovedSet(set);
       }
     });
   }
 
   class GameThread extends Thread
   {
     public void run()
     {
       final Thread thisThread = Thread.currentThread();
 
       waitForAllPlayersToConnect();
 
 /*
         // precondition
         if (! _players.allConnected()) {
 	String msg = "Implementation error: Not all players registered!";
 	if (_logger.isInfoEnabled())
 	_logger.info(msg);
 	throw new IllegalStateException(msg);
 	}*/
 
       if (_logger.isInfoEnabled())
       {
         _logger.info("-- starting game --");
       }
 
       int turn = 0;
       while (_gameThread == thisThread &&
              !_cardStack.empty() && _players.allConnected())
       {
 
         if (_logger.isInfoEnabled())
         {
           _logger.info("-- starting turn " + turn++ + " --");
         }
 
         int nbCardToAdd = 3;
         if (_board.getNbCards() < 12)
         {
           nbCardToAdd = Math.min(12 - _board.getNbCards(), _cardStack.size());
         }
         pushCardOnBoard(nbCardToAdd);
 
         startTurn();
 
         waitForTurnToEnd();
 
         if (_logger.isInfoEnabled())
         {
           _logger.info("-- ending turn --");
         }
       }
       if (_logger.isInfoEnabled())
       {
         _logger.info("-- Ending Game -- ");
       }
       // FIXME we probably don't want to terminate here.
       // we want the user to play until he is tired or there is a timeout.
       terminate();
     }
   }
 
   public void start()
   {
     _cardStack.shuffle();
     _gameThread.setDaemon(true);
     _gameThread.start();
   }
 
   public int getTurnLength()
   {
     return _turnLengthInSeconds;
   }
 
   public void setTurnLength(final int turnInSeconds)
   {
     _turnLengthInSeconds = turnInSeconds;
   }
 
   void startTurn()
   {
     _endedTurn = false;
     final int seconds = getTurnLength();
     _turnTimer = new Timer();
     _turnTimer.schedule(new TimerTask()
     {
       public void run()
       {
         endTurn();
 //        _turnTimer.cancel(); //Terminate the timer thread
       }
     }, seconds * 1000);
   }
 
   synchronized boolean endedTurn()
   {
     return _endedTurn;
   }
 
   synchronized void endGame()
   {
     if (_logger.isInfoEnabled())
     {
       _logger.info("endGame()!");
     }
     _gameThread = null;
     notifyAll();
   }
 
   synchronized void endTurn()
   {
     if (_logger.isInfoEnabled())
     {
       _logger.info("Turn's up!");
     }
     _endedTurn = true;
     _turnTimer.cancel();
     notifyAll();
   }
 
   private void waitForAllPlayersToConnect()
   {
     synchronized (this)
     {
       while (!_players.allConnected())
       {
         try
         {
           wait();
         }
         catch (InterruptedException e)
         {
         }
       }
     }
   }
 
   /*
   private void waitForAllPlayersToBeDisconnected() {
       if (_logger.isInfoEnabled())
           _logger.info("waitForAllPlayersToBeDisconnected");
       synchronized  (this) {
           while (! _players.noneConnected()) {
               if (_logger.isInfoEnabled())
                   _logger.info("nbPlayersConnected:" + _players.getCurrentNbPlayers());
               try {
                   wait();
               } catch (InterruptedException e) {
                   _logger.error("IE",e);  // FIXME - cleanup
               }
           }
       }
   }
   */
   void waitForTurnToEnd()
   {
     while (!endedTurn())
     {
       synchronized (this)
       {
         try
         {
           wait();
         }
         catch (InterruptedException e)
         {
           _logger.error("IE", e);   // FIXME - cleanup
         }
       }
     }
   }
 
   private void pushCardOnBoard(final int nbCards)
   {
     // precondition
     if (nbCards > _cardStack.size())
     {
       final String msg = "Can't add more cards than present in the stack!";
       if (_logger.isInfoEnabled())
       {
         _logger.info(msg);
       }
       throw new IllegalStateException(msg);
     }
 
     final CardProperties[] cardsToAdd = _cardStack.pop(nbCards);
     if (_logger.isInfoEnabled())
     {
       _logger.info("-- adding " + nbCards + " on board --");
       _logger.info("-- " + CardProperties.toString(_board.getCards()) +
                    " - " + CardProperties.toString(cardsToAdd) + " --");
     }
     _board.addCards(cardsToAdd);
   }
 
   private void removeMatchedSet(final CardSet set) throws MatchingException, BoardException
   {
     if (_logger.isInfoEnabled())
     {
       if (_logger.isInfoEnabled())
       {
         _logger.info("trying to remove a set:" + CardProperties.toString(set.getCards()));
       }
     }
     _board.matchSet(set);
 //            if (_logger.isInfoEnabled())
 //                _logger.info("CardSet removed");
   }
 
   public void terminate()
   {
     if (_logger.isInfoEnabled())
     {
       _logger.info("Closing connections");
     }
     _players.close();
     //         waitForAllPlayersToBeDisconnected();
     // disconnecting from JSetGameServer?
     // FIXME
   }
 
   public String getName()
   {
     return _name;
   }
 
   public int getCurrentNbPlayers()
   {
     return _players.getCurrentNbPlayers();
   }
 
   public int getMaxNbPlayers()
   {
     return _players.getMaxNbPlayers();
   }
 
   public SetGameConnection connect(final SetGamePlayer player)
   {
     if (_logger.isInfoEnabled())
     {
       _logger.info("Connecting player:" + player.getName() + ">");
     }
     final GameConnectionImpl connection;
     synchronized (this)
     {
       connection = _players.addPlayer(player);
       if (_logger.isInfoEnabled())
       {
         _logger.info("Added player " + player);
       }
       notifyAll();
     }
     return connection;
   }
 
   void notifyAddedCards(final CardProperties[] cards)
   {
     _players.fireAddedCardsEvent(cards);
   }
 
   void notifyRemovedSet(final CardSet set)
   {
     _players.fireRemovedSetEvent(set);
   }
 
   public int getID()
   {
     return _id;
   }
 }