/****************************************************************
    * Licensed to the Apache Software Foundation (ASF) under one   *
    * or more contributor license agreements.  See the NOTICE file *
    * distributed with this work for additional information        *
    * regarding copyright ownership.  The ASF licenses this file   *
    * to you under the Apache License, Version 2.0 (the            *
    * "License"); you may not use this file except in compliance   *
    * with the License.  You may obtain a copy of the License at   *
    *                                                              *
   *   http://www.apache.org/licenses/LICENSE-2.0                 *
   *                                                              *
   * Unless required by applicable law or agreed to in writing,   *
   * software distributed under the License is distributed on an  *
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
   * KIND, either express or implied.  See the License for the    *
   * specific language governing permissions and limitations      *
   * under the License.                                           *
   ****************************************************************/
  
  
  
  package org.apache.james.socket;
  
  import org.apache.avalon.cornerstone.services.connection.ConnectionHandler;
  import org.apache.avalon.excalibur.pool.Poolable;
  import org.apache.avalon.framework.container.ContainerUtil;
  import org.apache.avalon.framework.logger.AbstractLogEnabled;
  import org.apache.avalon.framework.logger.Logger;
  import org.apache.avalon.framework.service.ServiceException;
  import org.apache.avalon.framework.service.ServiceManager;
  import org.apache.avalon.framework.service.Serviceable;
  import org.apache.james.api.dnsservice.DNSService;
  import org.apache.james.util.InternetPrintWriter;
  import org.apache.james.util.watchdog.Watchdog;
  import org.apache.james.util.watchdog.WatchdogTarget;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InterruptedIOException;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.net.Socket;
  import java.net.SocketException;
  
  /**
   * Common Handler code
   */
  public abstract class AbstractJamesHandler extends AbstractLogEnabled implements ConnectionHandler, Poolable,Serviceable {
  
  
      private static final int DEFAULT_OUTPUT_BUFFER_SIZE = 1024;
  
      private static final int DEFAULT_INPUT_BUFFER_SIZE = 1024;
  
      /** Name used by default */
      private static final String DEFAULT_NAME = "Handler-ANON";
  
      /**
       * The thread executing this handler
       */
      private Thread handlerThread;
  
      /**
       * The TCP/IP socket over which the service interaction
       * is occurring
       */
      protected Socket socket;
  
      /**
       * The writer to which outgoing messages are written.
       */
      protected PrintWriter out;
      
      /**
       * The incoming stream of bytes coming from the socket.
       */
      protected InputStream in;
  
      /**
       * The reader associated with incoming characters.
       */
      protected CRLFTerminatedReader inReader;
  
      /**
       * The socket's output stream
       */
      protected OutputStream outs;
      
      /**
       * The watchdog being used by this handler to deal with idle timeouts.
       */
      protected Watchdog theWatchdog;
  
      /**
       * The watchdog target that idles out this handler.
      */
     private WatchdogTarget theWatchdogTarget = new JamesWatchdogTarget();
 
     /**
      * This method will be implemented checking for the correct class
      * type.
      * 
      * @param theData Configuration Bean.
      */
     public abstract void setConfigurationData(Object theData);
     
 
     /**
      * The remote host name obtained by lookup on the socket.
      */
     protected String remoteHost = null;
 
     /**
      * The remote IP address of the socket.
      */
     protected String remoteIP = null;
 
     /**
      * The DNSService
      */
     protected DNSService dnsServer = null;
 
     /**
      * Used for debug: if not null enable tcp stream dump.
      */
     private String tcplogprefix = null;
 
     /**
      * Names the handler.
      * This name is used for contextual logging.
      */
     private String name = DEFAULT_NAME;
     
 
     /**
      * @see org.apache.avalon.framework.service.Serviceable#service(org.apache.avalon.framework.service.ServiceManager)
      */
     public void service(ServiceManager arg0) throws ServiceException {
         setDnsServer((DNSService) arg0.lookup(DNSService.ROLE));
     }
 
     /**
      * Helper method for accepting connections.
      * This MUST be called in the specializations.
      *
      * @param connection The Socket which belongs to the connection 
      * @throws IOException get thrown if an IO error is detected
      */
     protected void initHandler( Socket connection ) throws IOException {
         this.socket = connection;
         remoteIP = socket.getInetAddress().getHostAddress();
         remoteHost = dnsServer.getHostName(socket.getInetAddress());
 
         try {
             synchronized (this) {
                 handlerThread = Thread.currentThread();
             }
             in = new BufferedInputStream(socket.getInputStream(), DEFAULT_INPUT_BUFFER_SIZE);
             outs = new BufferedOutputStream(socket.getOutputStream(), DEFAULT_OUTPUT_BUFFER_SIZE);
             // enable tcp dump for debug
             if (tcplogprefix != null) {
                 outs = new SplitOutputStream(outs, new FileOutputStream(tcplogprefix+"out"));
                 in = new CopyInputStream(in, new FileOutputStream(tcplogprefix+"in"));
             }
             
             // An ASCII encoding can be used because all transmissions other
             // that those in the message body command are guaranteed
             // to be ASCII
             inReader = new CRLFTerminatedReader(in, "ASCII");
             
             out = new InternetPrintWriter(outs, true);
         } catch (RuntimeException e) {
             StringBuffer exceptionBuffer = 
                 new StringBuffer(256)
                     .append("[" + toString() + "] Unexpected exception opening from ")
                     .append(remoteHost)
                     .append(" (")
                     .append(remoteIP)
                     .append("): ")
                     .append(e.getMessage());
             String exceptionString = exceptionBuffer.toString();
             getLogger().error(exceptionString, e);
             throw e;
         } catch (IOException e) {
             StringBuffer exceptionBuffer = 
                 new StringBuffer(256)
                     .append("[" + toString() + "] Cannot open connection from ")
                     .append(remoteHost)
                     .append(" (")
                     .append(remoteIP)
                     .append("): ")
                     .append(e.getMessage());
             String exceptionString = exceptionBuffer.toString();
             getLogger().error(exceptionString, e);
             throw e;
         }
         
         if (getLogger().isInfoEnabled()) {
             StringBuffer infoBuffer =
                 new StringBuffer(128)
                         .append("[" + toString() + "]Connection from ")
                         .append(remoteHost)
                         .append(" (")
                         .append(remoteIP)
                         .append(")");
             getLogger().info(infoBuffer.toString());
         }
     }
 
     /**
      * The method clean up and close the allocated resources
      */
     private void cleanHandler() {
         // Clear the Watchdog
         if (theWatchdog != null) {
             ContainerUtil.dispose(theWatchdog);
             theWatchdog = null;
         }
 
         // Clear the streams
         try {
             if (inReader != null) {
                 inReader.close();
             }
         } catch (IOException ioe) {
             getLogger().warn("[" + toString() + "] Unexpected exception occurred while closing reader: " + ioe);
         } finally {
             inReader = null;
         }
 
         in = null;
 
         if (out != null) {
             out.close();
             out = null;
         }
         outs = null;
 
         try {
             if (socket != null) {
                 socket.close();
             }
         } catch (IOException ioe) {
             getLogger().warn("[" + toString() + "] Unexpected exception occurred while closing socket: " + ioe);
         } finally {
             socket = null;
         }
         
         remoteIP = null;
         remoteHost = null;
 
         synchronized (this) {
             handlerThread = null;
         }
     }
 
     /**
      * @see org.apache.avalon.cornerstone.services.connection.ConnectionHandler#handleConnection(java.net.Socket)
      */
     public void handleConnection(Socket connection) throws IOException {
         initHandler(connection);
 
         final Logger logger = getLogger();
         try {
             
             // Do something:
             handleProtocol();
             
             logger.debug("[" + toString() + "] Closing socket");
         } catch (SocketException se) {
             // Indicates a problem at the underlying protocol level
             if (logger.isWarnEnabled()) {
                 String message =
                     new StringBuffer(64)
                         .append("[" + toString() + "]Socket to ")
                         .append(remoteHost)
                         .append(" (")
                         .append(remoteIP)
                         .append("): ")
                         .append(se.getMessage()).toString();
                 logger.warn(message);
                 logger.debug(se.getMessage(), se);
             }
         } catch ( InterruptedIOException iioe ) {
             if (logger.isErrorEnabled()) {
                 StringBuffer errorBuffer =
                     new StringBuffer(64)
                         .append("[" + toString() + "] Socket to ")
                         .append(remoteHost)
                         .append(" (")
                         .append(remoteIP)
                         .append(") timeout.");
                 logger.error( errorBuffer.toString(), iioe );
             }
         } catch ( IOException ioe ) {
             if (logger.isWarnEnabled()) {
                 String message =
                     new StringBuffer(256)
                             .append("[" + toString() + "] Exception handling socket to ")
                             .append(remoteHost)
                             .append(" (")
                             .append(remoteIP)
                             .append(") : ")
                             .append(ioe.getMessage()).toString();
                 logger.warn(message);
                 logger.debug( ioe.getMessage(), ioe );
             }
         } catch (RuntimeException e) {
             errorHandler(e);
         } finally {
             //Clear all the session state variables
             cleanHandler();
             resetHandler();
         }
     }
 
     /**
      * Method which will be colled on error
      *  
      * @param e the RuntimeException
      */
     protected void errorHandler(RuntimeException e) {
         if (getLogger().isErrorEnabled()) {
             getLogger().error( "[" + toString() + "] Unexpected runtime exception: "
                                + e.getMessage(), e );
         }
     }
 
 
     /**
      * Handle the protocol
      * 
      * @throws IOException get thrown if an IO error is detected
      */
     protected abstract void handleProtocol() throws IOException;
 
    /**
     * Resets the handler data to a basic state.
     */
     protected abstract void resetHandler();
 
 
     /**
      * Set the Watchdog for use by this handler.
      *
      * @param theWatchdog the watchdog
      */
     public void setWatchdog(Watchdog theWatchdog) {
         this.theWatchdog = theWatchdog;
     }
 
     /**
      * Gets the Watchdog Target that should be used by Watchdogs managing
      * this connection.
      *
      * @return the WatchdogTarget
      */
     WatchdogTarget getWatchdogTarget() {
         return theWatchdogTarget;
     }
 
     /**
      * Idle out this connection
      */
     void idleClose() {
         if (getLogger() != null) {
             getLogger().error("[" + toString() + "] Service Connection has idled out.");
         }
         try {
             if (socket != null) {
                 socket.close();
             }
         } catch (Exception e) {
             // ignored
         } finally {
             socket = null;
         }
 
         synchronized (this) {
             // Interrupt the thread to recover from internal hangs
             if (handlerThread != null) {
                 handlerThread.interrupt();
                 handlerThread = null;
             }
         }
 
     }
 
     /**
      * This method logs at a "DEBUG" level the response string that
      * was sent to the service client.  The method is provided largely
      * as syntactic sugar to neaten up the code base.  It is declared
      * private and final to encourage compiler inlining.
      *
      * @param responseString the response string sent to the client
      */
     private final void logResponseString(String responseString) {
         if (getLogger().isDebugEnabled()) {
             getLogger().debug("[" + toString() + "] Sent: " + responseString);
         }
     }
 
     /**
      * Write and flush a response string.  The response is also logged.
      * Should be used for the last line of a multi-line response or
      * for a single line response.
      *
      * @param responseString the response string sent to the client
      */
     public final void writeLoggedFlushedResponse(String responseString) {
         out.println(responseString);
         out.flush();
         logResponseString(responseString);
     }
 
     /**
      * Write a response string.  The response is also logged.
      * Used for multi-line responses.
      *
      * @param responseString the response string sent to the client
      */
     public final void writeLoggedResponse(String responseString) {
         out.println(responseString);
         logResponseString(responseString);
     }
 
     /**
      * A private inner class which serves as an adaptor
      * between the WatchdogTarget interface and this
      * handler class.
      */
     private class JamesWatchdogTarget
         implements WatchdogTarget {
 
         /**
          * @see org.apache.james.util.watchdog.WatchdogTarget#execute()
          */
         public void execute() {
             AbstractJamesHandler.this.idleClose();
         }
 
         /**
          * Used for context sensitive logging
          */
         @Override
         public String toString() {
             return AbstractJamesHandler.this.toString();
         }
     }
 
     /**
      * If not null, this will enable dump to file for tcp connections
      * 
      * @param streamDumpDir the dir
      */
     public void setStreamDumpDir(String streamDumpDir) {
         if (streamDumpDir != null) {
             String streamdumpDir=streamDumpDir;
             this.tcplogprefix = streamdumpDir+"/" + getName() + "_TCP-DUMP."+System.currentTimeMillis()+".";
             File logdir = new File(streamdumpDir);
             if (!logdir.exists()) {
                 logdir.mkdir();
             }
         } else {
             this.tcplogprefix = null;
         }
     }
 
     public void setDnsServer(DNSService dnsServer) {
         this.dnsServer = dnsServer;
     }
 
     /**
      * The name of this handler.
      * Used for context sensitive logging.
      * @return the name, not null
      */
     public final String getName() {
         return name;
     }
 
     /**
      * The name of this handler.
      * Note that this name should be file-system safe.
      * Used for context sensitive logging.
      * @param name the name to set
      */
     public final void setName(final String name) {
         if (name == null) {
             this.name = DEFAULT_NAME;
         } else {
             this.name = name;
         }
     }
 
     /**
      * Use for context sensitive logging.
      * @return the name of the handler
      */
     @Override
     public String toString() {
         return name;
     }
 }