/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    * 
    * This library 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
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.toolkit.tunnel;
  
  
  import java.io.*;
  import java.net.*;
  
  import org.caleigo.toolkit.log.*;
  
  /***
   *
   * @author  Mattias Hagstrand
   * @version 1.00
   * 
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2002-07-02  Mattias Hagstrand Creation
   */
  public class SocketTunnel extends AbstractTunnel
  {
      // Data members ------------------------------------------------------------
      protected InetAddress mAddress;
      protected int mPort;
      protected Socket mSocket;
      private boolean mIsInitialized;
      
      private String mDescription;
      
      // Constructors ------------------------------------------------------------
      protected SocketTunnel(Socket socket)
      {
          mSocket = socket;
          mDescription = mSocket.getInetAddress().getHostAddress();
      }
      
      public SocketTunnel(InetAddress address, int port)
      {
          super();
          
          mAddress = address;
          mPort = port;
          mDescription = mAddress.getHostAddress();
      }
      
      public SocketTunnel(InetAddress address, int port, ITunnelCodec codec)
      {
          super(codec);
          
          mAddress = address;
          mPort = port;
          mDescription = mAddress.getHostAddress();
      }
      
      // Superclass overrides ----------------------------------------------------
      public synchronized void initialize()
          throws IllegalStateException, TunnelException
      {
          if (mIsInitialized)
              throw new IllegalStateException("The tunnel is initialized");
  
          try
          {
              /* If mSocket is null this is a new connection:
               * Set up a connection to the server
               *
               * If mSocket is not null then a connection allready exists.
               */
              
              if (mSocket == null)
              {
                  mSocket = new Socket(mAddress, mPort);
                  this.setUpConnection();
              }
              mIsInitialized = true;    
              
              super.initialize();
          }
          catch (Exception e)
          {
              mIsInitialized = false;
             throw new TunnelException(e);
         }
     }
     
     public synchronized void finalize()
         throws IllegalStateException, TunnelException
     {
         if (!mIsInitialized)
             throw new IllegalStateException("The tunnel is not initialized");
         
         try
         {
             if (super.isActive())
                 super.finalize();
             mSocket.close();
         }
         catch (Exception e)
         {
             throw new TunnelException(e);
         }
         finally
         {
             mSocket = null;
             mIsInitialized = false;
         }
     }
     
     /*** Returns <code>true</code> if this tunnel is active, that is, if it is
      * correctly initialized. If this method returns <code>true</code> then
      * a call to finalize must not throw an IllegalStateException.
      */
     public synchronized boolean isActive()
     {
         return mIsInitialized;
     }
     
     /***
      * Returns an OutputStream that should be used to send messages.
      */
     protected OutputStream getOutputStream()
     {
         if (mSocket != null)
             try
             {
                 return mSocket.getOutputStream();
             }
             catch (Exception e)
             {
                 if (this.getLogLevel() <= AbstractTunnel.ERROR)
                     Log.printError(this, "Couldn't get output stream", e);
             }
         
         return null;
     }
     
     /***
      * Returns an InputStream that should be used to receive messages.
      */
     protected InputStream getInputStream()
     {
         if (mSocket != null)
             try
             {
                 return mSocket.getInputStream();
             }
             catch (Exception e)
             {
                 if (this.getLogLevel() <= ERROR)
                     Log.printError(this, "Couldn't get input stream", e);
             }
         
         return null;
     }
     
     /*** Returns a humanly readably text that describes the ITunnel.
      */
     public String getDescription()
     {
         return mDescription;
     }
     
     // Help methods ------------------------------------------------------------
     protected void setUpConnection()
         throws TunnelException
     {
         IStatusMessage statusMessage = null;
         
         try
         {
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(this.getOutputStream());
             ObjectInputStream objectInputStream = new ObjectInputStream(this.getInputStream());
             
             // Send connection message
             objectOutputStream.writeObject(this.createConnectionMessage());
             objectOutputStream.flush();
             
             // Wait for reply from server
             statusMessage = (IStatusMessage) objectInputStream.readObject();
         }
         catch (Exception e)
         {
             throw new TunnelException(e);
         }
         
         if (statusMessage.getStatus() == IStatusMessage.OK)
         {
             if (this.getLogLevel() <= AbstractTunnel.INFO)
                 Log.print(this, "Status message received: " + statusMessage.toString());
             for (int i = 0; i < mStatusCallbacks.size(); i++)
                 ((IStatusCallback) mStatusCallbacks.get(i)).handleInfo("Connection established");
         }
         else
         {
             if (this.getLogLevel() <= AbstractTunnel.ERROR)
                 Log.printError(this, "Couldn't establish connection: " + statusMessage.getMessage());
             for (int i = 0; i < mStatusCallbacks.size(); i++)
                 ((IStatusCallback) mStatusCallbacks.get(i)).handleError("Couldn't establish connection: " + statusMessage.getMessage(), null);
             throw new TunnelException("Couldn't establish connection: " + statusMessage.getMessage());
         }
     }
 }