/*
   @See License.txt@
    */
   
   package spellcast.client;
   
   import java.io.IOException;
   import java.net.InetAddress;
   import java.net.Socket;
  import java.util.ArrayList;
  
  import org.apache.log4j.Logger;
  import spellcast.event.ConnectionRequestEvent;
  import spellcast.event.GameEvent;
  import spellcast.net.NetConstants;
  import spellcast.net.VersionDetails;
  import spellcast.net.WizardSocket;
  import spellcast.ui.SpellcastView;
  import spellcast.util.TextUtil;
  
  /***
   * This class handles the socket functions for the client.
   *
   * @author Barrie Treloar
   */
  public class ClientConnectionHandler implements Runnable {
      private SpellcastView view;
      private Thread socketHandlerThread;
      private boolean isConnected;
      private InetAddress serverAddress;
      private int port;
      private String serverAddressString;
      private String wizardName;
      private String gender;
      private WizardSocket wizardSocket;
      private VersionDetails programVersionDetails;
      private boolean cleanupAlreadyDone;
  
      /***
       * A multi-threaded accessed object.  Ensure lock on <code>incomingEventQueueLock</code>
       * is obtained before accessing.
       */
      private ArrayList incomingEventQueue = new ArrayList(10);
      private Object incomingEventQueueLock = new Object();
  
      /***
       * The timeout for all socket operations is 300 milliseconds.
       */
      private static final int SOCKET_TIMEOUT = 300;
  
      private static final Logger logger = Logger.getLogger("client.net");
  
      public ClientConnectionHandler(
          SpellcastView view,
          VersionDetails programVersionDetails) {
          this.view = view;
          this.programVersionDetails = programVersionDetails;
      }
  
      public void run() {
          GameEvent event = null;
  
          connectToServer();
  
          while (isConnected) {
              Thread.yield();
              try {
                  event = wizardSocket.receive();
                  if (event != null) {
                      addIncomingEvent(event);
                  }
              }
              catch (IOException e) {
                  logger.warn("Exception while reading message from server.", e);
                  isConnected = false;
              }
          }
          cleanup();
      }
  
      /***
       * Add an event to the incoming event queue.
       * When an event is added it calls <code>notify</code> to 
       * allow any waiting threads to attempt to continue.
       */
      private void addIncomingEvent(GameEvent e) {
          synchronized (incomingEventQueueLock) {
              incomingEventQueue.add(e);
              incomingEventQueueLock.notify();
          }
      }
  
      /***
       * Removes the first event from the incoming event queue and returns it.
       * If there are no events in the queue this will <code>wait</code>
       * until one is added when the server sends the client an event, at which point 
       * the thread will be notified.
       * <p> 
       * If there is an IOException <code>cleanup</code> may call notify in which 
      * case the event will be null.
      */
     public GameEvent receive() {
         GameEvent result = null;
 
         synchronized (incomingEventQueueLock) {
             if (incomingEventQueue.size() == 0) {
                 try {
                     incomingEventQueueLock.wait();
                 }
                 catch (InterruptedException e) {
                     logger.error(
                         "Unexpectedly interrupted while waiting in "
                             + "ClientConnectionHandler.receive",
                         e);
                     throw new RuntimeException(
                         "Unexpectedly interrupted while waiting in "
                             + "ServerConnectionHandler.receive");
                 }
             }
             // This can happen if cleanup calls notify.  Otherwise there
             // should be a message on the queue
             if (incomingEventQueue.size() != 0) {
                 result = (GameEvent) incomingEventQueue.remove(0);
             }
         }
         return result;
     }
 
     /***
      * Send the event to the server.
      */
     public void send(GameEvent event) {
         try {
             if (isConnected) {
                 wizardSocket.send(event);
             }
         }
         catch (IOException e) {
             logger.warn("Exception whilst sending message.", e);
             isConnected = false;
             cleanup();
         }
     }
 
     /***
      * Connect to the Spellcast server.
      */
     private void connectToServer() {
         try {
             String hostString = TextUtil.getIPAddress(serverAddressString);
             port = TextUtil.getPort(serverAddressString);
             if (port == -1) {
                 port = NetConstants.SPELLCAST_NET_DEFAULT_PORT;
             }
             view.addMessage("Connecting to " + hostString + ":" + port + " ... ");
             Socket s = new Socket(hostString, port);
             s.setSoTimeout(SOCKET_TIMEOUT);
             wizardSocket = new WizardSocket(programVersionDetails);
             wizardSocket.setSocket(s);
             wizardSocket.send(new ConnectionRequestEvent(wizardName, gender));
             view.addMessage("established.\n");
             view.connected(true);
             isConnected = true;
         }
         catch (IOException e) {
             isConnected = false;
             logger.warn("Failed to connect to server.", e);
             view.addMessage("failed.\n");
             view.connected(false);
         }
     }
 
     /***
      * Request connection to the specified address and port.
      *
      * @param serverAddressString a server string of the form host[:port]
      * @param wizardName the name of the client's wizard
      * @param gender the gender of the client's wizard
      */
     public void connect(
         String serverAddressString,
         String wizardName,
         String gender) {
         this.serverAddressString = serverAddressString;
         this.wizardName = wizardName;
         this.gender = gender;
         cleanupAlreadyDone = false;
         socketHandlerThread = new Thread(this, "ClientToServer");
         socketHandlerThread.start();
     }
 
     /***
      * Request the network controller to disconnect from
      * the existing connection.
      */
     public void disconnect() {
         isConnected = false;
     }
 
     /***
      * Waits for the socket handler thread to complete.
      */
     public void join() {
         if (socketHandlerThread != null) {
             try {
                 socketHandlerThread.join();
             }
             catch (InterruptedException e) {
                 logger.error("Unexepectedly Interrupted.", e);
             }
         }
     }
 
     /***
      * Deallocate resources allocated used during <code>run</code> 
      * If this is a graceful cleanup the client state machine would have received
      * a disconnect event for itself and terminated cleanly BEFORE cleanup is called.
      * If this is not a graceful cleanup (because of IOExceptions) then the state
      * machine will not have terminated yet and is possibly blocked waiting for 
      * an external event. 
      */
     private synchronized void cleanup() {
         if (!cleanupAlreadyDone) {
             synchronized (incomingEventQueue) {
                 incomingEventQueue.notify();
             }
             if (wizardSocket != null) {
                 wizardSocket.close();
             }
             view.disconnected();
             socketHandlerThread = null;
             cleanupAlreadyDone = true;
         }
     }
 
 }