/*
    *  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.util;
  
  import java.io.IOException;
  import java.net.ServerSocket;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Random;
  import java.util.StringTokenizer;
  
  /***
   * Provides a data container for port ranges. All methods make sure
   * that only valid ports are added.
   *
   * @see xnap.util.prefs.PortRangeValidator 
   */
  public class PortRange {
  
      //--- Constant(s) ---
  
      public static final int MIN_PORT = 1;
      public static final int MAX_PORT = 65535;
  
      //--- Data field(s) ---
  
      /***
       * A set of {@link Integer} objects.
       */
      private HashSet list = new HashSet();
  
      //--- Constructor(s) ---
      
      public PortRange(int first, int last) 
      {
  		add(first, last);
      }
  
      public PortRange(String range)
      {
  		add(range);
      }
  
      public PortRange()
      {
      }
  
      //--- Method(s) ---
  
      /***
       * Adds all ports that are <code>first</code> <= port <= <code>last</code>.
       */
      public void add(int first, int last)
      {
  		for (int i = Math.max(first, MIN_PORT); i <= last && i <= MAX_PORT; 
  			 i++) {
  			list.add(new Integer(i));
  		}
      }
  
      /***
       * Adds <code>port</code> to the range.
       */
      public void add(int port)
      {
  		if (port >= MIN_PORT && port <= MAX_PORT) {
  			list.add(new Integer(port));
  		}
      }
  
      /***
       * Adds a range as a string.
       *
       * @see xnap.util.prefs.PortRangeValidator
       */
      public void add(String range)
      {
  		StringTokenizer t = new StringTokenizer(range, ";");
  		while (t.hasMoreTokens()) {
  			String ports = t.nextToken().trim();
 
 			if (ports.length() == 0) {
 				continue;
 			}
 
 			try {
 				if (ports.indexOf("-") != -1) {
 					StringTokenizer u = new StringTokenizer(ports, "-");
 					if (u.countTokens() == 2) {
 						add(Integer.parseInt(u.nextToken()),
 							Integer.parseInt(u.nextToken()));
 					}
 				}
 				else {
 					add(Integer.parseInt(ports));
 				}
 			}
 			catch (NumberFormatException e) {
 			}
 		}
     }
 
     /***
      * Tries to bind random ports from the range and returns the 
      * {@link ServerSocket} object if successful. 
      *
      * @return null, if no port could be bound
      */
     public ServerSocket bindRandom()
     {
 		// bind to next free port
 		for (PortRange.IntIterator i = random(); i.hasNext();) {
 			try {
 				return new ServerSocket(i.next());
 			} 
 			catch (IOException e) {
 			}
 		}
 
 		return null;
     }
 
     /***
      * Returns true, if port is in the range.
      */
     public boolean contains(int port)
     {
 		return list.contains(new Integer(port));
     }
 
     /***
      * Returns a random port from the range.
      *
      * @param defaultPort a default port
      * @return default, if range is empty
      */
     public int getRandom(int defaultPort)
     {
 		if (size() > 0) {
 			ArrayList copy = new ArrayList(list);
 			int index = (new Random()).nextInt(copy.size());
 			return ((Integer)copy.get(index)).intValue();
 		}
 	
 		return defaultPort;
     }
     
     /***
      * Returns an iterator over all contained ports.
      */
     public Iterator iterator()
     {
 		return list.iterator();
     }
 
     /***
      * Returns an iterator over a shuffeled instance.
      */
     public IntIterator random()
     {
 		ArrayList copy = new ArrayList(list);
 		Collections.shuffle(copy);
 		return new IntIterator(copy.iterator());
     }
 
     /***
      * Returns the number of ports.
      */
     public int size()
     {
 		return list.size();
     }
 
     /***
      * Returns an ordered string representation.
      */
     public String toString()
     {
 		StringBuffer sb = new StringBuffer();
 
 		ArrayList copy = new ArrayList(list);
 		Collections.sort(copy);
 
 		int start = 0;
 		int last = -1;
 		for (IntIterator i = new IntIterator(copy.iterator()); i.hasNext();) {
 			int current = i.next();
 			if (last == -1) {
 				start = current;
 			}
 			else if (current - last > 1) {
 				sb.append(start);
 				if (start != last) {
 					sb.append("-");
 					sb.append(last);
 				}
 				sb.append(";");
 				start = current;
 			}
 			last = current;
 		}
 
 		if (last != -1) {
 			sb.append(start);
 			if (start != last) {
 				sb.append("-");
 				sb.append(last);
 			}
 			sb.append(";");
 		}	
 
 		return sb.toString();
     }
 
     //--- Inner class(es) ---
 
     /***
      * An iterator over Integer objects.
      */
     public static class IntIterator
     {
 	
 		Iterator iterator;
 
 		public IntIterator(Iterator iterator)
 		{
 			this.iterator = iterator;
 		}
 	
 		public boolean hasNext()
 		{
 			return iterator.hasNext();
 		}
 
 		public int next()
 		{
 			return ((Integer)iterator.next()).intValue();
 		}
 	
 		public void remove()
 		{
 			iterator.remove();
 		}
 
     }
 
 }