/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation.
    *
   *  This program 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 General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.net;
  
  import java.io.IOException;
  import java.net.ConnectException;
  import java.net.Socket;
  import java.net.UnknownHostException;
  
  import org.apache.log4j.Logger;
  import org.xnap.XNap;
  
  /***
   * Provides a set of static methods for common network tasks.
   */
  public class NetHelper {
  
      //--- Data field(s) ---
  
      private static Logger logger = Logger.getLogger(NetHelper.class);
  
      //--- Method(s) ---
  
      /***
       * Enables the use of a socks proxy at <code>host:port</code>. 
       *
       * @param host hostname of the proxy
       * @param host port of the proxy
       */
      public static void enableSocksProxy(String host, int port) {
  		logger.debug("enabling socks proxy: " + host + ":" + port);
  
          System.getProperties().put("socksProxySet", "true");
          System.getProperties().put("socksProxyHost", host);
          System.getProperties().put("socksProxyPort", port + "");
      }
  
      /***
       * Disables the use of a socks proxy.
       */ 
      public static void disableSocksProxy() {
  		logger.debug("disabling socks proxy");
  
          System.getProperties().remove("socksProxySet");
          System.getProperties().remove("socksProxyHost");
          System.getProperties().remove("socksProxyPort");
      }
  
      /***
       * Enables the use of a http proxy at <code>host:port</code>. 
       *
       * @param host hostname of the proxy
       * @param host port of the proxy
       */
      public static void enableHttpProxy(String host, int port) {
  		logger.debug("enabling http proxy: " + host + ":" + port);
  
          System.getProperties().put("proxySet", "true");
          System.getProperties().put("proxyHost", host);
          System.getProperties().put("proxyPort", port + "");
      }
  
      /***
       * Disables the use of a http proxy.
       */ 
      public static void disableHttpProxy() {
  		logger.debug("disabling http proxy");
  
          System.getProperties().remove("proxySet");
          System.getProperties().remove("proxyHost");
          System.getProperties().remove("proxyPort");
      }
  
      /***
       * Returns a sensible error message.
       */
      public static String getErrorMessage(IOException e)
      {
  		String message = e.getLocalizedMessage();
  		if (e instanceof ConnectException) {
  			return XNap.tr("Connection refused");
  		}
 		else if (e instanceof UnknownHostException) {
 			return XNap.tr("Unknown host {0}", 
 						   (message != null) ? message : "");
 		}
 		else {
 			return XNap.tr("Error ({0})", 
 						   (message != null) ? message : e.toString());
 		}
     }
 
 	public static long ipToLongHiFirst(byte[] address)
 	{
         if (address.length != 4) {
             throw new IllegalArgumentException("byte array must be of length 4");
         }
 
         long ipNum = 0;
         long multiplier = 1;
         for (int i = 3; i >= 0; i--) {
             int byteVal = (address[i] + 256) % 256;
             ipNum += byteVal * multiplier;
             multiplier *= 256;
         }
         return ipNum;
 	}
 
     /***
      * Converts <code>ip</code> from an integer value to a dotted string
      * representation.
      *
      * @see #toIP(long)
      */
     public static String toIP(String ip)
     {
 		// int would do (it's 32-bit) but the range is too small
 		return toIP(Long.parseLong(ip));
     }
 
     /***
      * Converts <code>ip</code> from an integer value to a dotted string
      * representation.
      */
     public static String toIP(long ip)
     {
 		StringBuffer sb = new StringBuffer(4 * 3 + 3);
 	
 		sb.append(ip & 0xFF);
 		sb.append(".");
 		sb.append((ip >> 8) & 0xFF);
 		sb.append(".");
 		sb.append((ip >> 16) & 0xFF);
 		sb.append(".");
 		sb.append((ip >> 24) & 0xFF);
 
 		return sb.toString();
     }
 
     /***
      * Converts <code>ip</code> from an integer value to a dotted string
      * representation.
      */
     public static String toIPHiFirst(long ip)
     {
 		StringBuffer sb = new StringBuffer(4 * 3 + 3);
 	
 		sb.append((ip >> 24) & 0xFF);
 		sb.append(".");
 		sb.append((ip >> 16) & 0xFF);
 		sb.append(".");
 		sb.append((ip >> 8) & 0xFF);
 		sb.append(".");
 		sb.append(ip & 0xFF);
 
 		return sb.toString();
     }
 
     public static Socket connect(String host, int port, long timeout)
 		throws IOException
     {
 		SocketConnector runner = new SocketConnector(host, port);
 		Thread t = new Thread(runner, "SocketRunner " + host + ":" + port);
 		t.start();
 
 		return runner.getSocket(timeout);
     }
 
     //--- Inner Class(es) ---
 
     public static class SocketConnector implements Runnable
     {
 
 		String host;
 		int port;
 		Socket socket;
 		boolean done = false;
 		IOException exception;
 	
 		public SocketConnector(String host, int port)
 		{
 			this.host = host;
 			this.port = port;
 
 			this.socket = null;
 		}
 
 		public synchronized Socket getSocket(long timeout) throws IOException
 		{
 			if (!done) {
 				try {
 					this.wait(timeout);
 				}
 				catch (InterruptedException e) {
 				}
 			}
 
 			if (exception != null) {
 				throw (exception);
 			}
 			else if (socket == null) {
 				throw new IOException(XNap.tr("Socket timeout"));
 			}
 			else {
 				return socket;
 			}
 		}
 
 		public void run()
 		{
 			try {
 				socket = new Socket(host, port);
 			}
 			catch (IOException e) {
 				this.exception = e;
 			}
 
 			synchronized (this) {
 				done = true;
 				this.notify();
 			}
 		}
 
     }
 
 }