package net.sf.crispy.impl.rmi;
   
   import java.net.BindException;
   import java.rmi.Remote;
   import java.rmi.RemoteException;
   import java.rmi.registry.LocateRegistry;
   import java.rmi.registry.Registry;
   import java.rmi.server.ExportException;
   import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.Map;
  
  import net.sf.crispy.InvocationException;
  import net.sf.crispy.impl.MiniServer;
  import net.sf.crispy.impl.RmiExecutor;
  import net.sf.crispy.impl.ServiceManager;
  import net.sf.crispy.server.InterceptorHandlerCreator;
  import net.sf.crispy.server.ServiceEndpoint;
  import net.sf.crispy.server.SingleServiceContainer;
  import net.sf.crispy.util.Util;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * MiniRmiServer has the function to simulate a RMI Server. This is useful for test the RMI Client.
   * Do not use this Server in production.
   * 
   * @author Linke
   *
   */
  public class MiniRmiServer implements MiniServer {
   
  	public static final int PORT = 1098;
      protected static final Log log = LogFactory.getLog (MiniRmiServer.class);
      
      private static MiniRmiServer lastStartedRmiServer = null;
      
  	private String urlAndPort = null;
  	private int port = PORT;
  	private Map lookUpMap = new Hashtable();
  	private RmiInvocationHandler rmiInvocationHandler = null;
  	
  	
  	public MiniRmiServer() { this (PORT); }
  	public MiniRmiServer(int pvPort, RmiInvocationHandler pvRmiInvocationHandler) {
  		this (pvPort);
  		setRmiInvocationHandler(pvRmiInvocationHandler);
  	}
  	public MiniRmiServer(int pvPort) {
  		setPort(pvPort);
  	}
  	
  	public final int getPort() { return port; }
  	private void setPort(int pvPort) {
  		if (isStarted() == false) {
  			port = pvPort; 
  		} else {
  			log.warn("A RMI-Server is already started on port: " + getPort());
  		}
  	}
  	
  	public static boolean isStarted() { return (lastStartedRmiServer != null); }
  	private static void setStartedTrue(MiniRmiServer pvMiniRmiServer) { 
  		lastStartedRmiServer = pvMiniRmiServer;
  	}
  	private static void setStartedFalse() { 
  		lastStartedRmiServer = null;
  	}
  
  	public static MiniRmiServer getLastStartedRmiServer() {
  		return lastStartedRmiServer;
  	}
  	
  	public void setUrlAndPort(String pvUrlAndPort) { urlAndPort = pvUrlAndPort; }
  	public String getUrlAndPort() { return (urlAndPort == null ? RmiExecutor.DEFAULT_URL_AND_PORT : urlAndPort); }
  	
  	private void setRmiInvocationHandler(RmiInvocationHandler pvRmiInvocationHandler) { 
  		rmiInvocationHandler = pvRmiInvocationHandler; 
  	}
  	public RmiInvocationHandler getRmiInvocationHandler() {
  		if (rmiInvocationHandler == null) {
  			rmiInvocationHandler = getDefaultRmiInvocationHandler();
  		}
  		return rmiInvocationHandler; 
  	}
  	
  	public RmiInvocationHandler getDefaultRmiInvocationHandler() {
  		try {
  			return new RmiInvocationHandlerImpl();
  		} catch (RemoteException e) {
  			if (ServiceManager.DEBUG_MODE_ON) {
  				e.printStackTrace();
  			}
  		} 			
  		return null;
  	}
  	
      public void setInterceptorHandlerCreator(InterceptorHandlerCreator pvCreator) {
     	if (getRmiInvocationHandler() instanceof ServiceEndpoint) {
     		((ServiceEndpoint) getRmiInvocationHandler()).setInterceptorHandlerCreator(pvCreator);
     	} else {
     		log.warn("The RmiInvocationHandler is not a instance of ServiceEndpoint. Can't set the InterceptorHandlerCreator: " + pvCreator);
     	}
 	}
     public InterceptorHandlerCreator getInterceptorHandlerCreator() {
     	if (getRmiInvocationHandler() instanceof ServiceEndpoint) {
     		return ((ServiceEndpoint) getRmiInvocationHandler()).getInterceptorHandlerCreator();
     	} else {
     		log.warn("The RmiInvocationHandler is not a instance of ServiceEndpoint.");
     		return null;	
     	}
 	}
 
 	
 	public void addService (String pvServiceInterface, String pvServiceObject) {
 		try {
 			Object lvServiceObject = Util.createObject(pvServiceObject);
 			if (lvServiceObject instanceof Remote) {
 				addService(pvServiceInterface, (Remote) lvServiceObject);
 			} else {
 				addService(pvServiceInterface, lvServiceObject);
 			}
 		} catch (Exception e) {
 			if (ServiceManager.DEBUG_MODE_ON) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	public void addService (String pvLookName, Object pvServiceObject) {
 		RmiInvocationHandler lvHandler = getRmiInvocationHandler();
 		if (lvHandler instanceof SingleServiceContainer) {
 			((SingleServiceContainer) lvHandler).addService(pvLookName, pvServiceObject);
 		} else {
 			throw new InvocationException("Can't add service: " + pvLookName + 
 					". The RmiInvocationHandler isen't a implementation from the SingleServiceContainer instance.");
 		}
 	}
 
 	public void addService (String pvLookName, Remote pvServiceObject) {
 		lookUpMap.put(pvLookName, pvServiceObject);
 	}
 	
 	public void removeService (String pvLookName) {
 		lookUpMap.remove(pvLookName);
 		Registry registry = getRegistry(getPort());
 		try {
 			registry.unbind(pvLookName);
 		} catch (Exception e) {
 			if (log.isDebugEnabled()) {
 				log.debug("Can't remove service: " + pvLookName + " from MiniRmiServer: " + e, e);
 			}			
 		}
 	}
 		
 	public static Registry getRegistry(int pvPort) {
 		Registry registry = null;
 		try {
 			registry = LocateRegistry.getRegistry(pvPort);
 			registry.list();
 			return registry;
 		} catch (Exception t) {
 			try {
 				return LocateRegistry.createRegistry(pvPort);
 			} catch (ExportException e) {
 				if(e.getCause() != null && e.getCause() instanceof BindException) {
 					log.error("With the port: " + pvPort + " is a RMI-server already started (other JVM).");
 				}
 				if (ServiceManager.DEBUG_MODE_ON) {
 					e.printStackTrace();
 				}
 			} catch (RemoteException e) {
 				e.printStackTrace();
 			}
 		}
 		return registry;
 	}
 	
 	public void start() {
 //		if (System.getSecurityManager() == null) {
 //			log.info("Set RmiSecurityManager");
 //			System.setSecurityManager(new RMISecurityManager());
 //		}
 
 		if (isStarted() == false) {
 			try {
 				Registry registry = getRegistry(getPort()); 
 
 				// registered ServiceObjects
 				// lvHandlerImpl.registerServiceObject(...);
 				registry.rebind(RmiExecutor.LOOKUP_NAME, getRmiInvocationHandler());
 
 				Iterator it = lookUpMap.keySet().iterator();
 				while (it.hasNext()) {
 					String lvKey = (String) it.next();
 					Object lvValue = lookUpMap.get(lvKey);
 					registry.rebind(lvKey, (Remote) lvValue);
 				}
 
 				setStartedTrue(this);
 				if (log.isDebugEnabled()) {
 					log.debug("MiniRmiServer is waiting for requests ...");
 				}
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		} else {
 			if (log.isWarnEnabled()) {
 				log.warn("A RMI-server is already started on port: " + lastStartedRmiServer.getPort() + ". Only one RMI-server-instance per JVM is supported.");
 			}
 		}
 
 		
 	}
 	
 
 	public void stop() { 
 		try {
 			
 			Registry registry = getRegistry(getPort());
 			
 			Iterator it = lookUpMap.keySet().iterator();
 			String lvKey = null;
 			Object lvValue = null;
 			while (it.hasNext()) {
 				try {
 					lvKey = (String) it.next();
 					lvValue = lookUpMap.get(lvKey);
 					registry.unbind(lvKey);
 //					UnicastRemoteObject.unexportObject((Remote) lvValue, true);
 				} catch (Exception e) {
 					log.debug("Problem by unbind service: " + lvKey + " --> " + lvValue);
 				}
 			}
 			if (registry != null) {
 				registry.unbind(RmiExecutor.LOOKUP_NAME);
 			}
 			
 			registry = null;			
 		} catch (Exception e) {
 			if (ServiceManager.DEBUG_MODE_ON) {
 				e.printStackTrace();
 			}
 		}
 		finally {
 			setStartedFalse();
 		}
 		
 	}
 
 	public static void main(String[] args) {
 		Util.initJdkLogger();  
 		MiniServer lvMiniServer = new MiniRmiServer();
 
 		lvMiniServer.addService("test.crispy.example.service.Echo", "test.crispy.example.service.EchoImpl");
 		lvMiniServer.addService("test.crispy.example.service.Calculator", "test.crispy.example.service.CalculatorImpl");
 
 		lvMiniServer.start();
 	}
 }