/***************************************
 *                                     *
 *  JBoss: The OpenSource J2EE WebOS   *
 *                                     *
 *  Distributable under LGPL license.  *
 *  See terms of license at gnu.org.   *
 *                                     *
 ***************************************/
package org.jboss.test.remoting.performance.spring.rmi;

import EDU.oswego.cs.dl.util.concurrent.Latch;
import junit.framework.Test;
import org.jboss.jrunit.decorators.ThreadLocalDecorator;
import org.jboss.logging.Logger;
import org.jboss.remoting.InvokerLocator;
import org.jboss.test.remoting.performance.synchronous.PerformanceCallbackKeeper;
import org.jboss.test.remoting.performance.synchronous.PerformanceClientTest;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.remoting.rmi.RmiServiceExporter;

import java.rmi.server.UID;
import java.util.Map;

/**
 * @author <a href="mailto:tom@jboss.org">Tom Elrod</a>
 */
public class SpringRMIPerformanceClient extends PerformanceClientTest
{

   private SpringRMIServer springRMIServerService;
   private String clientSessionId = new UID().toString();

   protected static final Logger log = Logger.getLogger(SpringRMIPerformanceClient.class);

   public static Test suite()
   {
      return new ThreadLocalDecorator(SpringRMIPerformanceClient.class, 1);
   }

   public SpringRMIServer getSpringRMIServerService()
   {
      return springRMIServerService;
   }

   public void setSpringRMIServerService(SpringRMIServer springRMIServerService)
   {
      this.springRMIServerService = springRMIServerService;
   }

   public void init()
   {

      Resource res = new ClassPathResource("SpringRMIClientService.xml", SpringRMIPerformanceClient.class);
      BeanFactory factory = new XmlBeanFactory(res);
      springRMIServerService = (SpringRMIServer)factory.getBean("springRMIServerService");

      /*
      //super.init();

      String name = "//localhost/RMIServer";
//         RMIServer svr = (RMIServer) Naming.lookup(name);

      try
      {
         //Registry regsitry = LocateRegistry.getRegistry("localhost", rmiPort);
         Registry regsitry = LocateRegistry.getRegistry(rmiPort);
         Remote remoteObj = regsitry.lookup(name);
         rmiServer = (RMIServerRemote) remoteObj;
      }
      catch(Exception e)
      {
         log.error("Error initializating rmi client.", e);
      }
      */
   }

   /**
    * This will be used to create callback server
    *
    * @param port
    * @return
    * @throws Exception
    */
   protected InvokerLocator initServer(int port) throws Exception
   {
      return null;
   }

   protected PerformanceCallbackKeeper addCallbackListener(String sessionId, Latch serverDoneLock)
         throws Throwable
   {
      String springServiceXml = this.getClass().getResource("SpringRMIClientService.xml").getFile();
      
      ApplicationContext context = null;
      for (int i = 0; i < 10; i++)
      {
         try
         {
            context = new FileSystemXmlApplicationContext(springServiceXml);
            if (context != null)
               break;
         }
         catch (Exception e)
         {
            Thread.sleep(2000);
         }
      }
      
      SpringRMICallbackServer callbackServer = (SpringRMICallbackServer) context.getBean("springRMICallbackServerService");
      callbackServer.setClientSessionId(clientSessionId);
      callbackServer.setServerDoneLock(serverDoneLock);
      
/*
      Instead of exporting callback servers by injection, the following xml declaration is
      carried out programmatically.  Each callback server is registered under a name
      ending in the sessionId.
    
   <bean class="org.springframework.remoting.rmi.RmiServiceExporter">
      <property name="serviceName" value="SpringRMICallbackServerService"/>
      <property name="service" ref="springRMICallbackServerService"/>
      <!--<property name="servicePort" value="1300"/>-->
      <property name="serviceInterface" value="org.jboss.test.remoting.performance.spring.rmi.SpringRMICallbackServer"/>
      <property name="registryPort" value="1299"/>
   </bean> 
*/
      for (int i = 0; i < 10; i++)
      {
         try
         {
            RmiServiceExporter exporter = new RmiServiceExporter();
            exporter.setServiceName("SpringRMICallbackServerService:" + clientSessionId);
            exporter.setService(callbackServer);
            exporter.setServiceInterface(org.jboss.test.remoting.performance.spring.rmi.SpringRMICallbackServer.class);
            exporter.setRegistryPort(1299);
            exporter.afterPropertiesSet();
            log.info("exported SpringRMICallbackServerService:" + clientSessionId);
            break;
         }
         catch (Exception e)
         {
            Thread.sleep(2000);
         }
      }
      
      return callbackServer;

//      RMICallbackServer callbackServer = new RMICallbackServer(clientSessionId, serverDoneLock);
//      callbackServer.start();
//      return callbackServer;
   }

   protected void populateMetadata(Map metadata)
   {
      super.populateMetadata(metadata);
      metadata.put("transport", "spring_rmi");
      metadata.put("serialization", "java");
   }

   protected Object getBenchmarkAlias()
   {
      String config = System.getProperty("alias");
      if(config == null || config.length() == 0)
      {
         config = System.getProperty("jboss-junit-configuration");
         if(config == null || config.length() == 0)
         {
            config = "spring_rmi" + "_" + getNumberOfCalls() + "_" + getPayloadSize() + "_" + "java";
         }
      }
      return config;
   }


   protected Object makeInvocation(String method, Object param) throws Throwable
   {
      if(method.equals(NUM_OF_CALLS))
      {
         return springRMIServerService.sendNumberOfCalls(clientSessionId, param);
      }
      else if(method.equals(TEST_INVOCATION))
      {
         return springRMIServerService.makeCall(clientSessionId, param);
      }
      else
      {
         throw new Exception("Was not able to find remote method call for " + method);
      }
   }

   public static void main(String[] args)
   {
      SpringRMIPerformanceClient test = new SpringRMIPerformanceClient();
      try
      {
         test.setUp();
         test.testClientCalls();
         test.tearDown();
      }
      catch(Throwable throwable)
      {
         throwable.printStackTrace();
      }
   }

}