/*
   @See License.txt@
    */
   
   package spellcast.net;
   
   import java.io.BufferedInputStream;
   import java.io.BufferedOutputStream;
   import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.DataInputStream;
  import java.io.DataOutputStream;
  import java.io.EOFException;
  import java.io.IOException;
  import java.io.InterruptedIOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.net.Socket;
  
  import org.apache.log4j.Logger;
  import spellcast.event.GameEvent;
  import spellcast.event.MessageEvent;
  import spellcast.game.IPCHandle;
  import spellcast.model.Id;
  
  /***
   * A Wizard Socket encapsulates the network communication required
   * to send and receive game events.
   *
   * @author Barrie Treloar
   */
  public class WizardSocket implements IPCHandle {
      private static final int DEFAULT_BUFFER_SIZE = 256;
  
      private Socket socket;
      private Id id;
      private ByteArrayOutputStream baos;
      private int messageSize;
      private DataInputStream in;
      private DataOutputStream out;
      private VersionDetails programVersionDetails;
  
      private static final Logger logger = Logger.getLogger("wizard.net");
  
      public WizardSocket(VersionDetails programVersionDetails) {
          messageSize = -1;
          id = Id.NO_ONE;
          this.programVersionDetails = programVersionDetails;
          baos = new ByteArrayOutputStream();
      }
  
      /***
       * Receive a message from the socket.
       * If an entire message is not read in then return null.
       * Each time this method is called try to build up an entire message.
       * When one has been completely received then return it.
       * <p>
       * The format of the message is:
       * <ul>
       *   <li> MessageLength (int)
       *   <li> MessageBody (see marshalMessage and unmarshalMessage)
       * </ul>
       * 
       * @see marshalMessage
       * @see unmarshalMessage
       *
       * @throws IOException if an I/O error occurs
       */
      public GameEvent receive() throws IOException {
          GameEvent result = null;
  
          try {
              byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
              int bytesRead = 0;
  
              if (messageSize == -1) {
                  try {
                      messageSize = in.readInt();
                      logger.debug("Message size: " + messageSize);
                  }
                  catch (EOFException e) {
                      // If we are trying to read a new message its possible
                      // that we have yet to process a disconnect message
                      // because of multiple threads.
                      // Ignore an EOFException here.  If there truly is
                      // an exception it should get taken care of in the send phase.
                      return null;
                  }
              }
  
              // Determine how many more bytes to read in for a complete message;
              int bytesLeft = messageSize - baos.size();
              // Try to read the minimum of the buffer size or bytesLeft
              while (bytesLeft != 0) {
                  bytesRead = in.read(buf, 0, Math.min(bytesLeft, buf.length));
                  // If EOF reached throw an exception
                  if (bytesRead < 0) {
                      throw new EOFException(
                          "Unexpected End Of File reached for "
                             + socket.getInetAddress().getHostAddress());
                 }
                 // if nothing read in then break out of loop
                 if (bytesRead == 0) {
                     break;
                 }
                 // otherwise add the data read in to our message buffer
                 baos.write(buf, 0, bytesRead);
                 bytesLeft = messageSize - baos.size();
             }
 
             // Check for a complete message
             if (messageSize == baos.size()) {
                 result = unmarshalMessage();
                 messageSize = -1;
                 baos.reset();
             }
         }
         catch (InterruptedIOException ix) {
             // Ignore interrupted exceptions
         }
         return result;
     }
 
     /***
      * Send the GameEvent down the socket. 
      * The format of the message is:
      * <ul>
      *   <li> MessageLength (int)
      *   <li> MessageBody (see marshalMessage and unmarshalMessage)
      * </ul>
      * 
      * @see marshalMessage
      * @see unmarshalMessage
      */
     public void send(GameEvent e) throws IOException {
         byte[] messageBytes = marshalMessage(e);
 
         out.writeInt(messageBytes.length);
         out.write(messageBytes, 0, messageBytes.length);
         out.flush();
         logger.debug("Message size: " + messageBytes.length);
     }
 
     /***
      * Construct the message header and payload
      * <p>
      * The format of the message is:
      * <ul>
      *   <li> Program Name (String)
      *   <li> Protocol Major Version Number (int)
      *   <li> Protocol Minor Version Number (int)
      *   <li> Protocol Revision Version Number (int)
      *   <li> Payload (Serialized Object)
      * </ul>
      */
     private byte[] marshalMessage(GameEvent e) throws IOException {
         ByteArrayOutputStream messageBuffer = new ByteArrayOutputStream();
         DataOutputStream dos = new DataOutputStream(messageBuffer);
 
         dos.writeUTF(programVersionDetails.getProgramName());
         dos.writeInt(programVersionDetails.getMajorVersionNumber());
         dos.writeInt(programVersionDetails.getMinorVersionNumber());
         dos.writeInt(programVersionDetails.getRevisionVersionNumber());
         int headerSize = messageBuffer.size();
         logger.debug("Header Size: " + headerSize);
         ObjectOutputStream oos = new ObjectOutputStream(dos);
         oos.writeObject(e);
         logger.debug("Payload Size: " + (messageBuffer.size() - headerSize));
 
         return messageBuffer.toByteArray();
     }
 
     /***
      * Check the message header to ensure its protocol is compliant.
      * Take out the payload and re-construct the serialized GameEvent and
      * return it.
      * <p>
      * If the protocol is found to be non-compliant, send a return message
      * indicating the failure and throw an IOException.
      * Only the major version number is important.
      * <p>
      * If the major version number is less than the program's major version number
      * then the version is too old.<br>
      * If the major version number is greater than the program's major version number 
      * then the version is too new.<br>
      * Only when the major version number is identical to the program's major version
      * number is the version ok.
      * <p>
      * The format of the message is:
      * <ul>
      *   <li> Program Name (String)
      *   <li> Protocol Major Version Number (int)
      *   <li> Protocol Minor Version Number (int)
      *   <li> Protocol Revision Version Number (int)
      *   <li> Payload (Serialized Object)
      * </ul>
      */
     private GameEvent unmarshalMessage() throws IOException {
         GameEvent result = null;
         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
         DataInputStream dis = new DataInputStream(bais);
 
         int messageSize = dis.available();
         VersionDetails packetVersionDetails =
             new VersionDetails(dis.readUTF(), dis.readInt(), dis.readInt(), dis.readInt());
         int payloadSize = dis.available();
         logger.debug("Header Size: " + (messageSize - payloadSize));
         logger.debug("Payload Size: " + payloadSize);
 
         if (packetVersionDetails.getMajorVersionNumber()
             < programVersionDetails.getMajorVersionNumber()) {
             MessageEvent e =
                 new MessageEvent(
                     "Spellcast: Your client version is earlier than the server's version ("
                         + programVersionDetails
                         + ").  Please upgrade your client.");
             send(e);
             throw new IOException(
                 "Message protocol from "
                     + socket.getInetAddress().getHostAddress()
                     + " is too old.  Version Details received: "
                     + packetVersionDetails);
         }
         else
             if (packetVersionDetails.getMajorVersionNumber()
                 > programVersionDetails.getMajorVersionNumber()) {
                 MessageEvent e =
                     new MessageEvent(
                         "Spellcast: Your client version is later than the server's version ("
                             + programVersionDetails
                             + ").  Please upgrade the server.");
                 send(e);
                 throw new IOException(
                     "Message protocol from "
                         + socket.getInetAddress().getHostAddress()
                         + " is too new.  Version Details received: "
                         + packetVersionDetails);
             }
 
         try {
             ObjectInputStream ois = new ObjectInputStream(dis);
             Object o = ois.readObject();
             if (!(o instanceof GameEvent)) {
                 throw new IOException(
                     "Payload of message does not contain a GameEvent. "
                         + "Instead received: "
                         + o.getClass().getName());
             }
             result = (GameEvent) o;
         }
         catch (ClassNotFoundException cnfe) {
             throw new IOException(cnfe.getMessage());
         }
 
         return result;
     }
 
     /***
      * Immediately closes all input and output streams and closes the socket.
      * Other classes should ensure that no threads are currently using this object.
      */
     public void close() {
         if (in != null) {
             try {
                 in.close();
             }
             catch (IOException e) { /* exception ignored */
             }
             finally {
                 in = null;
             }
         }
         if (out != null) {
             try {
                 out.close();
             }
             catch (IOException e) { /* exception ignored */
             }
             finally {
                 out = null;
             }
         }
         if (socket != null) {
             try {
                 socket.close();
             }
             catch (IOException e) { /* exception ignored */
             }
             finally {
                 socket = null;
             }
         }
     }
 
     /***
      * Get the value of socket.
      *
      * @return value of socket.
      */
     public Socket getSocket() {
         return socket;
     }
 
     /***
      * Set the value of socket.
      *
      * @param v Value to assign to socket.
      */
     public void setSocket(Socket v) throws IOException {
         socket = v;
         in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
         out = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
     }
 
     /***
      * Get the value of id.
      *
      * @return value of id.
      */
     public Id getID() {
         return id;
     }
 
     /***
      * Set the value of id.
      *
      * @param v Value to assign to id.
      */
     public void setID(Id v) {
         id = v;
     }
 
     /***
      * Indicates whether the IPC system has connected the client yet.
      * The WizardSocket is only connected when it has an Id that is not
      * <code>Id.NO_ONE</code>.
      */
     public boolean isConnected() {
         return !getID().equals(Id.NO_ONE);
     }
 
 }