package com.atlassian.sal.core.lifecycle;
   
   import java.util.Collection;
   import java.util.Hashtable;
   
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginAccessor;
   import com.atlassian.plugin.PluginController;
   import com.atlassian.plugin.event.PluginEventManager;
  import com.atlassian.plugin.event.events.PluginEnabledEvent;
  import com.atlassian.plugin.event.events.PluginFrameworkStartedEvent;
  import com.atlassian.plugin.osgi.factory.OsgiPlugin;
  import com.atlassian.sal.api.lifecycle.LifecycleAware;
  
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableMap;
  
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.invocation.InvocationOnMock;
  import org.mockito.runners.MockitoJUnitRunner;
  import org.mockito.stubbing.Answer;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.ServiceEvent;
  import org.osgi.framework.ServiceListener;
  import org.osgi.framework.ServiceReference;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.notNullValue;
  import static org.mockito.Matchers.any;
  import static org.mockito.Matchers.anyString;
  import static org.mockito.Matchers.same;
  import static org.mockito.Mockito.doAnswer;
  import static org.mockito.Mockito.doThrow;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.never;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  @RunWith(MockitoJUnitRunner.class)
  public class TestDefaultLifecycleManager
  {
      private final String pluginKey = "pluginKey";
  
      @Mock private PluginEventManager pluginEventManager;
      @Mock private PluginAccessor pluginAccessor;
      @Mock private BundleContext bundleContext;
  
      @Mock private Bundle pluginBundle;
      @Mock private PluginController pluginController;
      private ServiceListener serviceListener;
  
      private boolean isApplicationSetup;
      private int notifyOnStartCalled;
      private DefaultLifecycleManager defaultLifecycleManager;
  
      @Before
      public void setUp() throws Exception
      {
          // Setup object under test
  
          isApplicationSetup = false;
          defaultLifecycleManager = new DefaultLifecycleManager(pluginEventManager, pluginAccessor, bundleContext)
          {
              @Override
              public boolean isApplicationSetUp()
              {
                  return isApplicationSetup;
              }
  
              @Override
              protected void notifyOnStart()
              {
                  super.notifyOnStart();
                  ++notifyOnStartCalled;
              }
          };
  
          // Setup recurrent fixtures
  
          pluginBundle = mockBundle(pluginKey);
          // We need to use an answer here so we get serviceListener set during the call to facilitate race condition tests, and for
          // the same reason we can't use a vanilla ArgumentCaptor here (with polluting every serviceListener usage site).
          final Answer answer = new Answer()
          {
              @Override
              public Object answer(final InvocationOnMock invocation) throws Throwable
              {
                  serviceListener = (ServiceListener) invocation.getArguments()[0];
                  return null;
              }
          };
          doAnswer(answer).when(bundleContext).addServiceListener(any(ServiceListener.class), anyString());
      }
  
     @Test
     public void onStartCalledForServicesRegisteredBeforeDefaultLifecycleManagerIsInitialized() throws Exception
     {
         final LifecycleAware lifecycleAware = mock(LifecycleAware.class);
         final ServiceReference<LifecycleAware> service = registerService(pluginBundle, lifecycleAware);
         when(bundleContext.getServiceReferences(LifecycleAware.class, null)).thenReturn(ImmutableList.of(service));
 
         defaultLifecycleManager.postConstruct();
 
         isApplicationSetup = true;
         enablePlugin(pluginKey);
 
         // Should not be called yet, as things haven't started
         verify(lifecycleAware, never()).onStart();
 
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         // And now it should have started
         verify(lifecycleAware).onStart();
 
         // And this is a convenient test to check resource management. This isn't perfect (we should check calls are balanced),
         // but it's not bad and picks up the likely broken code cases.
         verify(bundleContext).ungetService(service);
     }
 
     @Test
     public void onStartCalledWhenPluginFrameworkStartedIfApplicationIsSetup() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         final LifecycleAware lifecycleAware = mockLifecycleAwareAndRegisterService(pluginBundle);
         enablePlugin(pluginKey);
 
         // Should not be called yet, as things haven't started
         verify(lifecycleAware, never()).onStart();
 
         isApplicationSetup = true;
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         // And now it should have started
         verify(lifecycleAware).onStart();
     }
 
     @Test
     public void onStartCalledWhenStartCalledIfApplicationIsSetupAfterPluginFrameworkStarted() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         final LifecycleAware lifecycleAware = mockLifecycleAwareAndRegisterService(pluginBundle);
         enablePlugin(pluginKey);
 
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         // Should not be called yet, as things haven't started
         verify(lifecycleAware, never()).onStart();
 
         isApplicationSetup = true;
         defaultLifecycleManager.start();
 
         // And now it should have started
         verify(lifecycleAware).onStart();
     }
 
     @Test
     public void onStartCalledWhenPluginEnabledAfterStarted() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         final LifecycleAware lifecycleAware = mockLifecycleAwareAndRegisterService(pluginBundle);
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
         isApplicationSetup = true;
         defaultLifecycleManager.start();
 
         // Should not be called yet, as plugin is not enabled
         verify(lifecycleAware, never()).onStart();
 
         enablePlugin(pluginKey);
 
         // Should have been called now, in response to plugin being enabled
         verify(lifecycleAware).onStart();
     }
 
     @Test
     public void onStartCalledWhenLifecycleAwareRegisteredAfterPluginEnabled() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
         isApplicationSetup = true;
         defaultLifecycleManager.start();
 
         enablePlugin(pluginKey);
 
         final LifecycleAware lifecycleAware = mockLifecycleAwareAndRegisterService(pluginBundle);
         // Should have been called now, since the system is started and the plugin is enabled
         verify(lifecycleAware).onStart();
     }
 
     @Test
     public void notifyOnStartCalledWhenPluginFrameworkStartedWhenSetup() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         isApplicationSetup = true;
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         assertThat(notifyOnStartCalled, is(1));
     }
 
     @Test
     public void notifyOnStartCalledWhenStartCalledIfApplicationIsSetupAfterPluginFrameworkStarted() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         // Not yet setup, so we should not have started yet
         assertThat(notifyOnStartCalled, is(0));
 
         isApplicationSetup = true;
         defaultLifecycleManager.start();
 
         assertThat(notifyOnStartCalled, is(1));
     }
 
     @Test
     public void notifyOnStartOnlyCalledOnceEvenWhenBothPluginFrameworkStartedAndStartCalledWhenSetup() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         isApplicationSetup = true;
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
         defaultLifecycleManager.start();
 
         assertThat(notifyOnStartCalled, is(1));
     }
 
     @Test
     public void onStartNotCalledWhenLifecycleAwareUnregisteredBeforeStart() throws Exception
     {
         defaultLifecycleManager.postConstruct();
         // This is the shape you see if a plugin fails to enable but does get some services up before being disabled.
         final LifecycleAware lifecycleAware = mock(LifecycleAware.class);
         final ServiceReference serviceReference = registerService(pluginBundle, lifecycleAware);
         unregisterService(serviceReference);
 
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
         isApplicationSetup = true;
         defaultLifecycleManager.start();
     }
 
     @Test
     public void verifyListenerRegistrationManagement() throws Exception
     {
         defaultLifecycleManager.postConstruct();
 
         assertThat(serviceListener, notNullValue());
 
         verify(pluginEventManager).register(defaultLifecycleManager);
         // This is a little smoke and mirrors, in that we just captured it, but i want to keep this test orthogonal, and it serves
         // to document the listener registration management also.
         verify(bundleContext).addServiceListener(same(serviceListener), anyString());
 
 
         verify(pluginEventManager, never()).unregister(defaultLifecycleManager);
         verify(bundleContext, never()).removeServiceListener(serviceListener);
 
         defaultLifecycleManager.preDestroy();
 
         verify(pluginEventManager).unregister(defaultLifecycleManager);
         verify(bundleContext).removeServiceListener(serviceListener);
     }
 
     @Test
     public void serviceDeregisteredJustAfterPostConstructSnapshotIsNotLeaked() throws Exception
     {
         // This is a very greybox test, but i think there's logic worth exercising
         final LifecycleAware lifecycleAware = mock(LifecycleAware.class);
         final ServiceReference<LifecycleAware> serviceReference = registerService(pluginBundle, lifecycleAware);
         // Arrange that just after DefaultLifecycleManager.postConstruct asks for the references, one of them goes away.
         when(bundleContext.getServiceReferences(LifecycleAware.class, null)).thenAnswer(
                 new Answer<Collection<ServiceReference<LifecycleAware>>>()
                 {
                     @Override
                     public Collection<ServiceReference<LifecycleAware>> answer(final InvocationOnMock invocation)
                             throws Throwable
                     {
                         // The idea is that BundleContext.getServiceReferences return the one service, and then it unregistered
                         final ImmutableList<ServiceReference<LifecycleAware>> services = ImmutableList.of(serviceReference);
                         unregisterService(serviceReference);
                         return services;
                     }
                 });
 
         defaultLifecycleManager.postConstruct();
 
         // This is kind of a bit kludgy in terms of the test scenario, but it's the only really reasonable way to arrange we'd
         // detect the failure we're looking for. The alternative is to add debug logging for this scenario and capture logging.
         enablePlugin(pluginKey);
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
         isApplicationSetup = true;
         defaultLifecycleManager.start();
 
         // We should not start the lifecyleAware, because it wasn't registered by the time we started.
         verify(lifecycleAware, never()).onStart();
     }
 
     @Test
     public void onStartExceptionsAreCaught() throws Exception
     {
         // It would be even better if we could test other instances of LifecycleAware are unaffected also, but without playing
         // crazy brittle games on the HashSet ordering, i don't see a way to make such a test reliable.
         defaultLifecycleManager.postConstruct();
 
         final LifecycleAware lifecycleAware = mock(LifecycleAware.class);
         final ServiceReference<LifecycleAware> service = registerService(pluginBundle, lifecycleAware);
         doThrow(new RuntimeException("Test onStart failure")).when(lifecycleAware).onStart();
         enablePlugin(pluginKey);
 
         // Should not be called yet, as things haven't started
         verify(lifecycleAware, never()).onStart();
 
         isApplicationSetup = true;
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         // And now it should have started
         verify(lifecycleAware).onStart();
         // Check resource management in the exception case also
         verify(bundleContext).ungetService(service);
     }
 
     @Test
     public void staleServiceReferencesReturningNullBundleAndLifecycleAreHandled() throws Exception
     {
         verifyStaleServiceReferencesAreHandled(true);
     }
 
     @Test
     public void staleServiceReferencesReturningNullLifecycleAreHandled() throws Exception
     {
         verifyStaleServiceReferencesAreHandled(false);
     }
 
     private void verifyStaleServiceReferencesAreHandled(final boolean makeBundleNull) throws Exception
     {
         // This tests a race between DefaultLifecycleManager.notifyLifecycleAwareIfStartedAndEnabled() and service deregistration.
         // It's not worth the effort of actually constructing the race, we can just rig return values ahead of time.
         defaultLifecycleManager.postConstruct();
 
         final LifecycleAware lifecycleAware = mock(LifecycleAware.class);
         final ServiceReference<LifecycleAware> service = registerService(pluginBundle, lifecycleAware);
         enablePlugin(pluginKey);
 
         if (makeBundleNull)
         {
             when(service.getBundle()).thenReturn(null);
         }
         when(bundleContext.getService(service)).thenReturn(null);
 
         isApplicationSetup = true;
         defaultLifecycleManager.onPluginFrameworkStarted(new PluginFrameworkStartedEvent(pluginController, pluginAccessor));
 
         // In fact the majority of the verification here is that we don't throw, but it's worth checking a few details
 
         // We shouldn't have called onStart(). Hard to imagine how we could have, but i guess aggressive (broken) caching might.
         verify(lifecycleAware, never()).onStart();
         // We shouldn't unget in this case, because we didn't get successfully.
         verify(bundleContext, never()).ungetService(service);
     }
 
     private void enablePlugin(final String pluginKey)
     {
         // Mark plugin enabled in accessor ...
         when(pluginAccessor.isPluginEnabled(pluginKey)).thenReturn(true);
         // ... and fire the event
         defaultLifecycleManager.onPluginEnabled(new PluginEnabledEvent(mock(Plugin.class)));
     }
 
     private Bundle mockBundle(final String pluginKey)
     {
         final Bundle bundle = mock(Bundle.class);
         final ImmutableMap<String, String> headers = ImmutableMap.<String, String>builder()
                 .put(OsgiPlugin.ATLASSIAN_PLUGIN_KEY, pluginKey)
                 .build();
         when(bundle.getHeaders()).thenReturn(new Hashtable<String, String>(headers));
         return bundle;
     }
 
     private LifecycleAware mockLifecycleAwareAndRegisterService(final Bundle bundle)
     {
         final LifecycleAware lifecycleAware = mock(LifecycleAware.class);
         registerService(bundle, lifecycleAware);
         return lifecycleAware;
     }
 
     private ServiceReference<LifecycleAware> registerService(final Bundle bundle, final LifecycleAware lifecycleAware)
     {
         @SuppressWarnings("unchecked")
         // Mocking generics requires the unchecked cast
         final ServiceReference<LifecycleAware> serviceReference = mock(ServiceReference.class);
         when(serviceReference.getBundle()).thenReturn(bundle);
         when(bundleContext.getService(serviceReference)).thenReturn(lifecycleAware);
         // Only send the ServiceEvent if we've been initialized, which is mean serviceListener has been set
         if (null != serviceListener)
         {
             serviceListener.serviceChanged(new ServiceEvent(ServiceEvent.REGISTERED, serviceReference));
         }
         return serviceReference;
     }
 
     private void unregisterService(final ServiceReference serviceReference)
     {
         // Only send the ServiceEvent if we've been initialized, which is mean serviceListener has been set
         if (null != serviceListener)
         {
             serviceListener.serviceChanged(new ServiceEvent(ServiceEvent.UNREGISTERING, serviceReference));
         }
         when(serviceReference.getBundle()).thenReturn(null);
     }
 }