package org.xvsm.remote.freepastry;
   
   import java.io.IOException;
   import java.net.InetAddress;
   import java.net.InetSocketAddress;
   import java.net.UnknownHostException;
   import java.util.Hashtable;
   
   import org.xvsm.core.Capi;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.internal.exceptions.XCoreRemoteException;
  
  import rice.environment.Environment;
  import rice.p2p.commonapi.Endpoint;
  import rice.p2p.replication.Replication;
  import rice.pastry.NodeHandle;
  import rice.pastry.NodeIdFactory;
  import rice.pastry.PastryNode;
  import rice.pastry.PastryNodeFactory;
  import rice.pastry.commonapi.PastryIdFactory;
  import rice.pastry.socket.SocketPastryNodeFactory;
  import rice.pastry.standard.RandomNodeIdFactory;
  import rice.persistence.LRUCache;
  import rice.persistence.MemoryStorage;
  import rice.persistence.PersistentStorage;
  import rice.persistence.Storage;
  import rice.persistence.StorageManagerImpl;
  
  /***
   * connects the peer to the FreePastry-network
   * 
   * @author Hannu-Daniel Goiss
   */
  public class FreePastryConnection {
  	private static FreePastryConnection connectionInstance;
  	
      private NodeIdFactory noteIdFactory;
      private PastryNodeFactory pastryNodeFactory;
      private NodeHandle noteHandle;
      private PastryNode pastryNode;
      private PastryIdFactory pastryIdFactory;
      private MyPastImpl past;
      private Endpoint endpoint;
      private int localport;
      private int numberOfContainers;
      
      /***
  	 * @return the numberOfContainers
  	 */
  	public int getNumberOfContainers() {
  		return numberOfContainers;
  	}
  
  	public int getLocalport() {
      	return localport;
      }
  	
  	/***
  	 * @return the endpoint
  	 */
  	public Endpoint getEndpoint() {
  		return endpoint;
  	}
  
  	/***
  	 * @param endpoint the endpoint to set
  	 */
  	public void setEndpoint(Endpoint endpoint) {
  		this.endpoint = endpoint;
  	}
  
  	public FreePastryConnection(Hashtable<String, String> env) {
  	    Environment fpenv = new Environment();
  		
  	    fpenv.getParameters().setString("nat_search_policy","never");
  		
  		try {
  			String remoteUri = env.get("RemoteURI");
  			int port = Integer.parseInt(env.get("Port"));
  			this.numberOfContainers = Integer.parseInt(env.get("Containers"));
  			
  			this.localport = port;
  			
  			InetSocketAddress bootaddress = null;
  			try {
  				if(remoteUri.startsWith("localhost") == false)
  					bootaddress = new InetSocketAddress(remoteUri.substring(0, remoteUri.indexOf(":")), Integer.parseInt(remoteUri.substring(remoteUri.indexOf(":")+1)));
  				else
  					bootaddress = new InetSocketAddress(InetAddress.getLocalHost().getHostAddress(), Integer.parseInt(remoteUri.substring(remoteUri.indexOf(":")+1)));
  			}
  			catch(UnknownHostException uhe) {
  				throw new FatalException(uhe);
  			}
  //			InetSocketAddress bootaddress = new InetSocketAddress(remoteUri.substring(0, remoteUri.indexOf(":")), Integer.parseInt(remoteUri.substring(remoteUri.indexOf(":")+1)));
  
  		    this.noteIdFactory = new RandomNodeIdFactory(fpenv);
  		    this.pastryNodeFactory = new SocketPastryNodeFactory(this.noteIdFactory, port, fpenv);
  		    this.noteHandle = ((SocketPastryNodeFactory)this.pastryNodeFactory).getNodeHandle(bootaddress);
 		    this.pastryNode = this.pastryNodeFactory.newNode(this.noteHandle);
 			
 		    synchronized(this.pastryNode) {
 		      while(!this.pastryNode.isReady() && !this.pastryNode.joinFailed()) {
 		        this.pastryNode.wait(500);
 		        
 		        if (this.pastryNode.joinFailed()) {
 		          throw new FatalException("Could not join the FreePastry ring.  Reason:"+pastryNode.joinFailedReason()); 
 		        }
 		      }       
 		    }
 		    
 		    System.err.println("Finished creating new node "+pastryNode);    
 		    
 		    pastryIdFactory = new rice.pastry.commonapi.PastryIdFactory(fpenv);
 
 		    String storageDirectory = "/tmp/storage"+this.pastryNode.getId().hashCode();
 //		    String storageDirectory = "./MYstorage";
 		    
 		    Storage stor = new PersistentStorage(this.pastryIdFactory, storageDirectory, 4 * 1024 * 1024, this.pastryNode.getEnvironment());
 		    
 //		    PastImpl needs the following:
 //		        * The Node
 //		        * StorageManager
 //		        * The number of Replicas to maintain — this is a parameter that you can tune to adjust overhead vs. chance of data-loss
 //		        * An instance name
 
 //		    MyPastImpl test = new MyPastImpl(this.pastryNode, new StorageManagerImpl(this.pastryIdFactory, stor, new LRUCache(new MemoryStorage(this.pastryIdFactory), 512 * 1024, this.pastryNode.getEnvironment())), 2, "");
 
 		    MyPastImpl test;
 		    if(numberOfContainers == 0) {
 			    test = new MyPastImpl(this.pastryNode, new MyStorageManagerImpl(this.pastryIdFactory, stor), 0, "");
 		    }
 		    else
 		    	test = new MyPastImpl(this.pastryNode, new MyStorageManagerImpl(this.pastryIdFactory, stor), this.numberOfContainers-1, "");
 	
 		    Replication rep = test.getReplication();
 		    
 		    this.past = test;
 		    
 //		    this.past = new PastImpl(this.pastryNode, new StorageManagerImpl(this.pastryIdFactory, stor, new LRUCache(new MemoryStorage(this.pastryIdFactory), 512 * 1024, this.pastryNode.getEnvironment())), 3, "");
 		}
 		catch(IOException ioe) {
 			new FatalException(ioe);
 		}
 		catch(InterruptedException ie) {
 			new FatalException(ie);
 		}
 	}
 	
 	public synchronized static FreePastryConnection getInstance(Hashtable<String, String> env) {
 		if (connectionInstance == null) {
 			connectionInstance = new FreePastryConnection(env);
 		}
 		return connectionInstance;
 	}
 	
 	public synchronized static FreePastryConnection getInstance() throws XCoreException {
 		if (connectionInstance == null) {
 			throw new FatalException("FreePastryConnection not instantiated");
 		}
 		return connectionInstance;
 	}
 
 	public void stop() throws XCoreRemoteException {
 /*		try {
 			if(delete == true) {
 				manager.deleteAccount();
 			}
 		}
 		catch(XMPPException xe) {
 			throw new FatalException(xe);
 		}
 		connection.disconnect();
 */		
 	}
 
 	/***
 	 * @return the noteIdFactory
 	 */
 	public NodeIdFactory getNoteIdFactory() {
 		return noteIdFactory;
 	}
 
 	/***
 	 * @return the pastryNodeFactory
 	 */
 	public PastryNodeFactory getPastryNodeFactory() {
 		return pastryNodeFactory;
 	}
 
 	/***
 	 * @return the noteHandle
 	 */
 	public NodeHandle getNoteHandle() {
 		return noteHandle;
 	}
 
 	/***
 	 * @return the pastryNode
 	 */
 	public PastryNode getPastryNode() {
 		return pastryNode;
 	}
 	
 	/***
 	 * @return the pastryIdFactory
 	 */
 	public PastryIdFactory getPastryIdFactory() {
 		return pastryIdFactory;
 	}
 
 	/***
 	 * @return the past
 	 */
 	public MyPastImpl getPast() {
 		return past;
 	}
 
 }