package org.xvsm.lookup.gnutella;
   
   import java.io.IOException;
   import java.io.ObjectInputStream;
   import java.io.ObjectOutputStream;
   import java.net.BindException;
   import java.net.InetAddress;
   import java.net.InetSocketAddress;
   import java.net.Socket;
  import java.net.SocketAddress;
  import java.net.UnknownHostException;
  import java.util.ArrayList;
  import java.util.Hashtable;
  
  import org.xvsm.lookup.gnutella.exceptions.NotFoundException;
  import org.xvsm.lookup.gnutella.objects.GnutellaRequest;
  import org.xvsm.lookup.gnutella.threads.ListenerThread;
  
  /***
   * Is the class that handles the Gnutella functions of a peer.
   * 
   * @author Hannu-Daniel Goiss
   */
  public class GnutellaPeer {
  	private Hashtable<String, Object> list = new Hashtable<String, Object>();
  	private ListenerThread listenerThread = null;
  	private Hashtable<String, Object> answer = new Hashtable<String, Object>();
  	private ArrayList<SocketAddress> peer = new ArrayList<SocketAddress>();
  	private int localPort;
  	private String serverIp;
  	private int serverPort;
  
  	/***
  	 * starting a standalone peer. Simply used for testing
  	 * 
  	 * @param args
  	 * @throws IOException
  	 * @throws ClassNotFoundException
  	 */
  	public static void main(String[] args) throws IOException,
  			ClassNotFoundException {
  		new GnutellaPeer(4600, "localhost", 4500);
  	}
  
  	/***
  	 * Constructor to initiate a peer using the local port and the server
  	 * ip-address as well as the port of the server
  	 * 
  	 * @param port
  	 * @param serverIp
  	 * @param serverPort
  	 * @throws UnknownHostException
  	 * @throws IOException
  	 * @throws ClassNotFoundException
  	 */
  	public GnutellaPeer(int port, String serverIp, int serverPort)
  			throws UnknownHostException, IOException, ClassNotFoundException {
  		this.localPort = port;
  		this.serverIp = serverIp;
  		this.serverPort = serverPort;
  
  		listenerThread = new ListenerThread(localPort, this);
  		listenerThread.start();
  
  		this.connect();
  	}
  
  	/***
  	 * connects the peer to the server to retrieve some addresses of other peers
  	 * 
  	 * @throws UnknownHostException
  	 * @throws IOException
  	 * @throws ClassNotFoundException
  	 */
  	public void connect() throws UnknownHostException, IOException,
  			ClassNotFoundException {
  		Socket socket = new Socket(serverIp, serverPort);
  
  		ObjectOutputStream oos = new ObjectOutputStream(socket
  				.getOutputStream());
  		ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  
  		oos.writeObject(new Integer(localPort));
  
  		peer = (ArrayList<SocketAddress>) ois.readObject();
  
  		socket.close();
  	}
  
  	/***
  	 * returns the list of objects, which have been published
  	 * 
  	 * @return
  	 */
  	public Hashtable<String, Object> getList() {
  		return list;
  	}
  
  	/***
 	 * adds an additional object to the list of objects, which have been
 	 * published
 	 * 
 	 * @param searchString
 	 * @param object
 	 */
 	public void publish(String searchString, Object object) {
 		this.list.put(searchString, object);
 	}
 
 	/***
 	 * removes an object for the list of objects, which have been published
 	 * 
 	 * @param searchString
 	 */
 	public void unpublish(String searchString) {
 		this.list.remove(searchString);
 	}
 
 	/***
 	 * sends a request to another peer. This function should not be used by
 	 * users of this api. The search function should be used instead.
 	 * 
 	 * @param request
 	 * @param throwException
 	 * @throws NotFoundException
 	 * @throws UnknownHostException
 	 * @throws IOException
 	 * @throws ClassNotFoundException
 	 */
 	public void senden(GnutellaRequest request, boolean throwException)
 			throws NotFoundException, UnknownHostException, IOException,
 			ClassNotFoundException {
 		if (peer == null) {
 			this.connect();
 			if (peer == null) {
 				if (throwException == true)
 					throw new NotFoundException(request.getSearchString());
 				else
 					return;
 			}
 		}
 		// this.answer = null;
 		this.answer.remove(request.getSearchString());
 
 		for (int i = 0; i < peer.size(); i++) {
 			try {
 				Socket socket = new Socket();
 				socket.connect(peer.get(i));
 
 				ObjectOutputStream oos = new ObjectOutputStream(socket
 						.getOutputStream());
 				oos.writeObject(request);
 				oos.flush();
 				socket.close();
 			} catch (BindException e) {
 
 			} catch (Exception e) {
 				System.err.println(peer.get(i));
 				e.printStackTrace();
 
 				peer.remove(i);
 				i--;
 			}
 		}
 	}
 
 	/***
 	 * function to search for an object in the gnutella network by its string.
 	 * 
 	 * @param searchString
 	 * @return
 	 * @throws UnknownHostException
 	 * @throws IOException
 	 * @throws ClassNotFoundException
 	 * @throws NotFoundException
 	 */
 	public Object search(String searchString) throws UnknownHostException,
 			IOException, ClassNotFoundException, NotFoundException {
 		if (this.list.containsKey(searchString) == true)
 			return this.list.get(searchString);
 
 		GnutellaRequest request = new GnutellaRequest(searchString,
 				new InetSocketAddress(InetAddress.getLocalHost(),
 						this.localPort));
 		this.senden(request, true);
 
 		long waittime = 0;
 
 		try {
 			Thread.sleep(10);
 		} catch (Exception e) {
 
 		}
 
 		while (waittime < 600) {
 			long begin = System.currentTimeMillis();
 			try {
 				Thread.sleep(20);
 			} catch (Exception e) {
 
 			}
 
 			// System.err.println("still waiting: " + waittime);
 
 			if (answer.containsKey(searchString) == true) {
 				// System.err.println("received result");
 				return this.answer.get(searchString);
 			}
 
 			waittime = waittime + (System.currentTimeMillis() - begin);
 		}
 		// socket.close();
 
 		throw new NotFoundException(request.getSearchString());
 	}
 
 	public int getLocalPort() {
 		return localPort;
 	}
 
 	public String getServerIp() {
 		return serverIp;
 	}
 
 	public int getServerPort() {
 		return serverPort;
 	}
 
 	public Hashtable<String, Object> getAnswer() {
 		return answer;
 	}
 }