package uba.db.sql.server;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.InetSocketAddress;
   import java.net.ServerSocket;
   import java.net.Socket;
   import java.net.SocketException;
   
  import org.apache.commons.lang.exception.ExceptionUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /***
   * @version $Revision$
   */
  public class Server {
      private static final Log log = LogFactory.getLog(Server.class);
      private InetSocketAddress serverAddress;
      private ServerProcessor serverProcessor;
      private ServerSocket serverSocket;
      private ServerState state;
  
      private static final String SERVER_THREAD_NAME = "UBADB Database Server Thread";
  
      public Server(InetSocketAddress serverAddress, File databaseDirectory) {
          this.serverAddress = serverAddress;
          serverProcessor = new ServerProcessor(databaseDirectory);
          switchToStopped();
      }
  
      public boolean isRunning() {
          return state.isRunning();
      }
  
      public synchronized void start() throws ServerStartUpException,
              ServerAlreadyRunningException {
          state.start();
      }
  
      public synchronized void stop() throws ServerAlreadyStoppedException {
          state.stop();
      }
  
      private void acceptConnectionFromClient() {
          try {
              Socket clientSocket = serverSocket.accept();
              log.info("Se establecio una conexión con: "
                      + clientSocket.getRemoteSocketAddress());
  
              handleRequestFrom(clientSocket);
          } catch (SocketException e) {
              // cuando se cierra el server se hace un close que genera esta excepcion
              // ese caso es normal, asi que no hay que mostrar ningun mensaje de error
              if (!isRunning()) {
                  log.error("Error en la conexion con el cliente", e);
              }
          } catch (IOException e) {
              
              log.error("No se pudo establecer la conexion con el cliente", e);
          }
      }
  
      private void closeServerSocket() {
          log.debug("Cerrando el socket del servidor");
  
          try {
              serverSocket.close();
              log.debug("Socket del servidor cerrado correctamente");
          } catch (Throwable t) {
              log.error("No se pudo cerrar correctamente el socket del servidor", t);
          }
  
          serverSocket = null;
      }
  
      private void connectionAcceptLoop() {
          while (isRunning()) {
              acceptConnectionFromClient();
          }
      }
  
      private void createServerSocket() throws ServerStartUpException {
          log.info("Creando el socket servidor en: " + serverAddress);
  
          try {
              serverSocket = new ServerSocket();
              serverSocket.bind(serverAddress);
          } catch (IOException e) {
              switchToStopped();
              throw new ServerStartUpException(e);
          }
      }
  
      private void handleRequestFrom(Socket clientSocket) {
          ClientRequestProcessor clientRequestProcessor = null;
  
          try {
              clientRequestProcessor = new ClientRequestProcessor(new DBProtocol(
                     serverProcessor), clientSocket.getInputStream(), clientSocket
                     .getOutputStream());
         } catch (IOException e) {
             log.error("No se pudo obtener la entrada/salida con el cliente", e);
             return;
         }
 
         try {
             clientRequestProcessor.handleRequests();
         } catch (ClientResquestHandlingException e) {
             log.error("Ocurrio un error al manejar los pedidos del cliente",
                       ExceptionUtils.getCause(e));
         }
     }
 
     private void switchToRunning() {
         state = new ServerRunning(this);
     }
 
     private void switchToStopped() {
         state = new ServerStopped(this);
     }
 
     protected void startWhenStopped() throws ServerStartUpException {
         switchToRunning();
         createServerSocket();
         Thread serverThread = new Thread(connectionAcceptRunnable(), SERVER_THREAD_NAME);
         serverThread.start();
     }
 
     private Runnable connectionAcceptRunnable() {
         return new Runnable() {
             public void run() {
                 try {
                     connectionAcceptLoop();
                 } finally {
                     log.info("Servidor finalizado");
                 }
             }
         };
     }
 
     protected synchronized void stopWhenRunning() {
         log.info("Parando la ejecución del servidor");
         switchToStopped();
         closeServerSocket();
         notifyAll();
     }
 }