/*
    * Copyright 2014 The Apache Software Foundation.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.juddi.v3.tck;
  
  import java.net.InetAddress;
  import java.net.URI;
  import java.rmi.registry.LocateRegistry;
  import java.rmi.registry.Registry;
  import java.util.Iterator;
  import java.util.Random;
  import org.apache.commons.configuration.ConfigurationException;
  import static org.apache.juddi.v3.tck.UDDI_090_SubscriptionListenerIntegrationBase.logger;
  import static org.apache.juddi.v3.tck.UDDI_090_SubscriptionListenerIntegrationBase.startManager;
  import static org.apache.juddi.v3.tck.UDDI_090_SubscriptionListenerIntegrationBase.stopManager;
  import org.junit.AfterClass;
  import org.junit.Assert;
  import org.junit.BeforeClass;
  
  /**
   *
   * @author Alex O'Ree
   */
  public class UDDI_090_RMIIntegrationTest extends UDDI_090_SubscriptionListenerIntegrationBase {
  
          private static UDDISubscriptionListenerImpl rmiSubscriptionListenerService = null;
          private static TckSubscriptionListenerRMI rmiSubscriptionListener = null;
          private static Registry registry;
          private static Integer randomPort = null;
          private static String hostname = null;
  
          @AfterClass
          public static void stop() throws ConfigurationException {
                  if (!TckPublisher.isEnabled()) {
                          return;
                  }
                  stopManager();
  
          }
  
          @BeforeClass
          public static void startup() throws Exception {
  
                  if (!TckPublisher.isEnabled()) {
                          return;
                  }
                  startManager();
                  int count = 0;
                  rmiSubscriptionListenerService = new UDDISubscriptionListenerImpl(0);
                  UDDISubscriptionListenerImpl.notifcationMap.clear();
                  UDDISubscriptionListenerImpl.notificationCount=0;
                  while (true && count < 5) {
                          try {
                                  count++;
                                  randomPort = 19800 + new Random().nextInt(99);
                                  logger.info("RMI Random port=" + randomPort);
                                  //bring up the RMISubscriptionListener
                                  URI rmiEndPoint = new URI("rmi://localhost:" + randomPort + "/tck/rmisubscriptionlistener");
                                  registry = LocateRegistry.createRegistry(rmiEndPoint.getPort());
  
                                  String path = rmiEndPoint.getPath();
                                  hostname = InetAddress.getLocalHost().getHostName();
                                  //starting the service
  
                                  //binding to the RMI Registry
                                  registry.bind(path, rmiSubscriptionListenerService);
  
                                  //double check that the service is bound in the local Registry
                                  Registry registry2 = LocateRegistry.getRegistry(rmiEndPoint.getHost(), rmiEndPoint.getPort());
                                  registry2.lookup(rmiEndPoint.getPath());
                                  break;
                          } catch (Exception ex) {
                                  logger.warn("trouble starting rmi endpoint " + ex.getMessage());
                          }
                  }
                  Assert.assertNotNull(registry);
                  Assert.assertNotNull(hostname);
          }
  
          @Override
          public boolean verifyDelivery(String findMe) {
                  for (int i = 0; i < TckPublisher.getSubscriptionTimeout(); i++) {
                          try {
                                  Thread.sleep(1000);
                          } catch (InterruptedException ex) {
                          }
                          logger.info(".");
                         //if (UDDISubscriptionListenerImpl.notificationCount > 0) {                        }
                 }
                 logger.info("RX " + UDDISubscriptionListenerImpl.notificationCount + " notifications");
                 Iterator<String> it = UDDISubscriptionListenerImpl.notifcationMap.values().iterator();
                 boolean found = false;
 
                 while (it.hasNext()) {
                         String test = it.next();
                         if (TckCommon.isDebug()) {
                                 logger.info("Notification: " + test);
                         }
                         if (test.toLowerCase().contains(findMe.toLowerCase())) {
                                 found = true;
                         }
                 }
 
                 if (!found) {
                         it = UDDISubscriptionListenerImpl.notifcationMap.values().iterator();
                         Thread.dumpStack();
                         while (it.hasNext()) {
                                 logger.info("Notification: " + it.next());
                         }
                 }
                 return found;
         }
 
         @Override
         public void reset() {
                 UDDISubscriptionListenerImpl.notifcationMap.clear();
                 UDDISubscriptionListenerImpl.notificationCount = 0;
 
         }
 
         @Override
         public String getXMLLocationOfServiceForDelivery() {
                 return TckSubscriptionListener.LISTENER_RMI_SERVICE_XML;
         }
 
         @Override
         public String getTransport() {
                 return "RMI";
         }
 
         @Override
         public int getPort() {
                 return randomPort;
         }
 
         @Override
         public String getHostame() {
                 return hostname;
         }
 
         @Override
         public String getSubscription1XML() {
                 return TckSubscriptionListenerRMI.SUBSCRIPTION_XML_RMI;
         }
 
         @Override
         public String getSubscription2XML() {
                 return TckSubscriptionListenerRMI.SUBSCRIPTION_XML2_RMI;
         }
 
         @Override
         public String getSubscription3XML() {
                 return TckSubscriptionListenerRMI.SUBSCRIPTION_XML3_RMI;
         }
 
         @Override
         public String getSubscriptionKey1() {
                 return TckSubscriptionListenerRMI.SUBSCRIPTION_KEY_RMI;
         }
 
         @Override
         public String getSubscriptionKey2() {
                 return TckSubscriptionListenerRMI.SUBSCRIPTION_KEY_RMI;
         }
 
         @Override
         public String getSubscriptionKey3() {
                 return TckSubscriptionListenerRMI.SUBSCRIPTION_KEY_RMI;
         }
 
         @Override
         public boolean IsEnabled() {
                 return TckPublisher.isRMI();
         }
 
 }