package com.atlassian.plugin.manager;
   
   import com.atlassian.plugin.MockPlugin;
   import com.atlassian.plugin.ModuleDescriptorFactory;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.event.PluginEventManager;
   import com.atlassian.plugin.loaders.PluginLoader;
   import com.google.common.base.Function;
   import com.google.common.base.Predicates;
  import com.google.common.collect.Collections2;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableMap;
  import com.google.common.collect.ImmutableSet;
  import com.google.common.collect.Maps;
  import com.google.common.collect.Sets;
  import org.junit.Assert;
  import org.junit.Before;
  import org.junit.Test;
  import org.mockito.Mockito;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  import java.util.regex.Pattern;
  
  public class TestDefaultPluginManagerDependentPlugins
  {
  
      private Collection<Plugin> enabledPlugins;
      private ImmutableMap<String, Plugin> pluginsByKey;
      private DefaultPluginManager pluginManager;
  
      private static Function<Plugin, String> GET_KEY = new Function<Plugin, String>()
      {
          @Override
          public String apply(Plugin input)
          {
              return input.getKey();
          }
      };
  
      @Before
      public void setUp() throws Exception
      {
          enabledPlugins = ImmutableList.<Plugin>of(
                  // Draw it on paper first if you want to modify it, the more letters in the key the lower row
                  new MockDepPlugin("root", Collections.<String>emptySet()),
  
                  new MockDepPlugin("a", ImmutableSet.of("root")),
                  new MockDepPlugin("b", ImmutableSet.of("root", "a")),
                  new MockDepPlugin("c", ImmutableSet.of("root")),
  
                  new MockDepPlugin("aa", ImmutableSet.of("a")),
                  new MockDepPlugin("ba", ImmutableSet.of("b")),
                  new MockDepPlugin("bb", ImmutableSet.of("b")),
                  new MockDepPlugin("ca", ImmutableSet.of("c")),
                  new MockDepPlugin("cb", ImmutableSet.of("c", "ca")),
  
                  new MockDepPlugin("aaa", ImmutableSet.of("aa")),
                  new MockDepPlugin("caa", ImmutableSet.of("c", "ca", "cb")),
  
                  new MockDepPlugin("disconnected.a", ImmutableSet.<String>of()),
                  new MockDepPlugin("disconnected.b", ImmutableSet.of("disconnected.a")),
                  new MockDepPlugin("disconnected.c", ImmutableSet.of("disconnected.b"))
          );
  
          pluginsByKey = Maps.uniqueIndex(enabledPlugins, GET_KEY);
  
          pluginManager = new DefaultPluginManager(Mockito.mock(PluginPersistentStateStore.class), Collections.<PluginLoader>emptyList(),
                  Mockito.mock(ModuleDescriptorFactory.class), Mockito.mock(PluginEventManager.class));
      }
  
      private Set<String> getDependentPluginKeys(String parentKey)
      {
          return getDependentPluginKeys(pluginsByKey.get(parentKey), enabledPlugins);
      }
  
      private Set<String> getDependentPluginKeys(Plugin root, Collection<Plugin> enabledPlugins)
      {
          return ImmutableSet.copyOf(Collections2.transform(
                  pluginManager.getDependentPlugins(root, enabledPlugins), GET_KEY));
      }
  
      @Test
      public void testNoDependencies() throws Exception
      {
          Assert.assertEquals(ImmutableSet.<String>of(), getDependentPluginKeys("aaa"));
      }
  
      @Test
      public void testSingleDependency() throws Exception
      {
         Assert.assertEquals(ImmutableSet.of("aaa"), getDependentPluginKeys("aa"));
     }
 
     @Test
     public void testSimpleTransitiveDependency() throws Exception
     {
         Assert.assertEquals(ImmutableSet.of("disconnected.b", "disconnected.c"), getDependentPluginKeys("disconnected.a"));
     }
 
     @Test
     public void testTransitiveDependency() throws Exception
     {
         Assert.assertEquals(ImmutableSet.of("aa", "aaa", "b", "ba", "bb"), getDependentPluginKeys("a"));
     }
 
     @Test
     public void testCrossLayerDependency() throws Exception
     {
         Assert.assertEquals(ImmutableSet.of("ca", "cb", "caa"), getDependentPluginKeys("c"));
     }
 
     @Test
     public void testFullTreeDependency() throws Exception
     {
         final Set<String> notDisconnected = Sets.filter(pluginsByKey.keySet(), Predicates.not(Predicates.contains(
                 Pattern.compile("disconnected|root"))));
         Assert.assertEquals(notDisconnected, getDependentPluginKeys("root"));
     }
 
     @Test(timeout = 1000)
     public void testCircularDependency() throws Exception
     {
         final ImmutableList<Plugin> plugins = ImmutableList.<Plugin>of(
                 new MockDepPlugin("a", ImmutableSet.of("c")),
                 new MockDepPlugin("b", ImmutableSet.of("a")),
                 new MockDepPlugin("c", ImmutableSet.of("b"))
         );
         Assert.assertEquals(ImmutableSet.of("b", "c"), getDependentPluginKeys(plugins.get(0), plugins));
     }
 
     @Test(timeout = 1000)
     public void testVeryDeepDependencyTreePerformance() throws Exception
     {
         final Map<String, Plugin> plugins = Maps.newHashMap();
         plugins.put("root", new MockDepPlugin("root", ImmutableSet.<String>of()));
 
         for (int lvl = 0; lvl < 10; lvl++)
         {
             final Set<String> existingKeys = ImmutableSet.copyOf(plugins.keySet());
             for (int i = 0; i < 10; i++)
             {
                 final String key = lvl + "." + i;
                 plugins.put(key, new MockDepPlugin(key, existingKeys));
             }
         }
 
         final Set<String> allButRoot = Sets.difference(plugins.keySet(), ImmutableSet.of("root"));
         Assert.assertEquals(allButRoot, getDependentPluginKeys(plugins.get("root"), plugins.values()));
     }
 }
 
 class MockDepPlugin extends MockPlugin
 {
     final Set<String> requiredPlugins;
 
     public MockDepPlugin(String key, Set<String> requiredPlugins)
     {
         super(key, null);
         this.requiredPlugins = requiredPlugins;
     }
 
     @Override
     public Set<String> getRequiredPlugins()
     {
         return requiredPlugins;
     }
 }