package com.atlassian.plugin.loaders;
   
   import com.atlassian.plugin.DefaultPluginArtifactFactory;
   import com.atlassian.plugin.ModuleDescriptorFactory;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginArtifact;
   import com.atlassian.plugin.PluginArtifactFactory;
   import com.atlassian.plugin.PluginException;
   import com.atlassian.plugin.PluginParseException;
  import com.atlassian.plugin.PluginState;
  import com.atlassian.plugin.event.PluginEventListener;
  import com.atlassian.plugin.event.PluginEventManager;
  import com.atlassian.plugin.event.events.PluginFrameworkShutdownEvent;
  import com.atlassian.plugin.factories.PluginFactory;
  import com.atlassian.plugin.impl.UnloadablePlugin;
  import com.atlassian.plugin.loaders.classloading.DeploymentUnit;
  import com.atlassian.plugin.loaders.classloading.Scanner;
  import com.google.common.collect.ImmutableList;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.TreeMap;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  
  /**
   * Plugin loader that delegates the detection of plugins to a Scanner instance. The scanner may monitor the contents
   * of a directory on disk, a database, or any other place plugins may be hidden.
   *
   * @since 2.1.0
   */
  public class ScanningPluginLoader implements DynamicPluginLoader, DiscardablePluginLoader
  {
      private static final Logger log = LoggerFactory.getLogger(ScanningPluginLoader.class);
  
      protected final com.atlassian.plugin.loaders.classloading.Scanner scanner;
      protected final Map<DeploymentUnit, Plugin> plugins;
      protected final List<PluginFactory> pluginFactories;
      protected final PluginArtifactFactory pluginArtifactFactory;
  
      /**
       * Constructor that provides a default plugin artifact factory
       *                                                                                     `
       * @param scanner The scanner to use to detect new plugins
       * @param pluginFactories The deployers that will handle turning an artifact into a plugin
       * @param pluginEventManager The event manager, used for listening for shutdown events
       * @since 2.0.0
       */
      public ScanningPluginLoader(final Scanner scanner, final List<PluginFactory> pluginFactories, final PluginEventManager pluginEventManager)
      {
          this(scanner, pluginFactories, new DefaultPluginArtifactFactory(), pluginEventManager);
      }
  
      /**
       * Construct a new scanning plugin loader with no default values
       *
       * @param scanner The scanner to use to detect new plugins
       * @param pluginFactories The deployers that will handle turning an artifact into a plugin
       * @param pluginArtifactFactory used to create new plugin artifacts from an URL
       * @param pluginEventManager The event manager, used for listening for shutdown events
       * @since 2.0.0
       */
      public ScanningPluginLoader(final Scanner scanner, final List<PluginFactory> pluginFactories, final PluginArtifactFactory pluginArtifactFactory, final PluginEventManager pluginEventManager)
      {
          checkNotNull(pluginFactories, "The list of plugin factories must be specified");
          checkNotNull(pluginEventManager, "The event manager must be specified");
          checkNotNull(scanner, "The scanner must be specified");
  
          plugins = new TreeMap<DeploymentUnit, Plugin>();
  
          this.pluginArtifactFactory = pluginArtifactFactory;
          this.scanner = scanner;
          this.pluginFactories = new ArrayList<PluginFactory>(pluginFactories);
  
          pluginEventManager.register(this);
      }
  
      public Iterable<Plugin> loadAllPlugins(final ModuleDescriptorFactory moduleDescriptorFactory)
      {
          scanner.scan();
  
          for (final DeploymentUnit deploymentUnit : scanner.getDeploymentUnits())
          {
              Plugin plugin = deployPluginFromUnit(deploymentUnit, moduleDescriptorFactory);
              plugin = postProcess(plugin);
              plugins.put(deploymentUnit, plugin);
          }
  
          if (scanner.getDeploymentUnits().isEmpty())
          {
              log.info("No plugins found to be deployed");
          }
  
          return ImmutableList.copyOf(plugins.values());
     }
 
     /**
      * @return all plugins, now loaded by the pluginLoader, which have been discovered and added since the
      * last time a check was performed.
      */
     public Iterable<Plugin> loadFoundPlugins(final ModuleDescriptorFactory moduleDescriptorFactory) throws PluginParseException
     {
         // find missing plugins
         final Collection<DeploymentUnit> updatedDeploymentUnits = scanner.scan();
 
         // create list while updating internal state
         final List<Plugin> foundPlugins = new ArrayList<Plugin>();
         for (final DeploymentUnit deploymentUnit : updatedDeploymentUnits)
         {
             if (!plugins.containsKey(deploymentUnit))
             {
                 Plugin plugin = deployPluginFromUnit(deploymentUnit, moduleDescriptorFactory);
                 plugin = postProcess(plugin);
                 plugins.put(deploymentUnit, plugin);
                 foundPlugins.add(plugin);
             }
         }
         if (foundPlugins.isEmpty())
         {
             log.info("No plugins found to be installed");
         }
 
         return ImmutableList.copyOf(foundPlugins);
     }
 
     public boolean supportsRemoval()
     {
         return true;
     }
 
     public boolean supportsAddition()
     {
         return true;
     }
 
     protected final Plugin deployPluginFromUnit(final DeploymentUnit deploymentUnit, final ModuleDescriptorFactory moduleDescriptorFactory)
     {
         Plugin plugin = null;
         String errorText = "No plugin factories found for plugin file " + deploymentUnit;
 
         String pluginKey = null;
         for (final PluginFactory factory : pluginFactories)
         {
             try
             {
                 final PluginArtifact artifact = pluginArtifactFactory.create(deploymentUnit.getPath().toURI());
                 pluginKey = factory.canCreate(artifact);
                 if (pluginKey != null)
                 {
                     plugin = factory.create(artifact, moduleDescriptorFactory);
                     if (plugin != null)
                     {
                         log.debug("Plugin factory '{}' created plugin '{}'.", factory.getClass().getName(), pluginKey);
                         break;
                     }
                 }
             }
             catch (final Throwable ex)
             {
                 log.error("Unable to deploy plugin '{}' from '{}'.", pluginKey, deploymentUnit);
                 log.error("Because of the following exception:", ex);
 
                 errorText = ex.getMessage();
                 break;
             }
         }
         if (plugin == null)
         {
             plugin = new UnloadablePlugin(errorText);
             if (pluginKey != null)
             {
                 plugin.setKey(pluginKey);
             }
             else
             {
                 plugin.setKey(deploymentUnit.getPath().getName());
             }
             log.debug("Could not find a suitable factory for plugin '{}' of '{}'", pluginKey, deploymentUnit);
         }
         else
         {
             log.debug("Plugin '{}' created from '{}'", plugin.getKey(), deploymentUnit);
         }
 
         return plugin;
     }
 
     /**
      * @param plugin - the plugin to remove
      * @throws com.atlassian.plugin.PluginException representing the reason for failure.
      */
     public void removePlugin(final Plugin plugin) throws PluginException
     {
         if (plugin.getPluginState() == PluginState.ENABLED)
         {
             throw new PluginException("Cannot remove enabled plugin '" + plugin.getKey() + '"');
         }
         if (!plugin.isUninstallable())
         {
             throw new PluginException("Cannot remove uninstallable plugin '" + plugin.getKey() + '"');
         }
 
         final DeploymentUnit deploymentUnit = findMatchingDeploymentUnit(plugin);
         plugin.uninstall();
 
         if (plugin.isDeleteable())
         {
             // If this throws (which it does if the file exists, it's directory is writable, and yet deletion fails),
             // we will leak resources. However, this is not unique to this code, and i'm loathe to change the exception
             // behaviour here in case there are ramifications in UPM. If this is getting restructured in 4.0 we can
             // hopefully revisit when we've got a backward compatibility break point.
             deleteDeploymentUnit(deploymentUnit);
         }
 
         plugins.remove(deploymentUnit);
         log.info("Removed plugin '" + plugin.getKey() + "'");
     }
 
     private void deleteDeploymentUnit(final DeploymentUnit deploymentUnit)
     {
         try
         {
             // Loop over to see if there are any other deployment units with the same filename. This will happen
             // if a newer plugin is uploaded with the same filename as the plugin being removed: in this case the
             // old one has already been deleted
             boolean found = false;
             for (final DeploymentUnit unit : plugins.keySet())
             {
                 if (unit.getPath().equals(deploymentUnit.getPath()) && !unit.equals(deploymentUnit))
                 {
                     found = true;
                     break;
                 }
             }
 
             if (!found)
             {
                 scanner.remove(deploymentUnit);
             }
         }
         catch (final SecurityException e)
         {
             throw new PluginException(e);
         }
     }
 
     private DeploymentUnit findMatchingDeploymentUnit(final Plugin plugin) throws PluginException
     {
         DeploymentUnit deploymentUnit = null;
         for (final Map.Entry<DeploymentUnit, Plugin> entry : plugins.entrySet())
         {
             // no, you don't want to use entry.getValue().equals(plugin) here as it breaks upgrades where it is a new
             // version of the plugin but the key and version number hasn't changed, and hence, equals() will always return
             // true
             if (entry.getValue() == plugin)
             {
                 deploymentUnit = entry.getKey();
                 break;
             }
         }
 
         if (deploymentUnit == null)
         {
             throw new PluginException("This pluginLoader has no memory of deploying the plugin you are trying remove: [" + plugin.getName() + "]");
         }
         return deploymentUnit;
     }
 
     /**
      * Called during plugin framework shutdown
      * @param event The shutdown event
      */
     @PluginEventListener
     public void onShutdown(final PluginFrameworkShutdownEvent event)
     {
         for (final Iterator<Plugin> it = plugins.values().iterator(); it.hasNext();)
         {
             final Plugin plugin = it.next();
             if (plugin.isUninstallable())
             {
                 plugin.uninstall();
             }
             it.remove();
         }
 
         scanner.reset();
     }
 
     /**
      * @deprecated Since 2.0.0, shutdown will automatically occur when the plugin framework is shutdown
      */
     @Deprecated
     public void shutDown()
     {
         onShutdown(null);
     }
 
     @Override
     public boolean isDynamicPluginLoader()
     {
         return true;
     }
 
     /**
      * Determines if the artifact can be loaded by any of its deployers
      *
      * @param pluginArtifact The artifact to test
      * @return True if this artifact can be loaded by this loader
      * @throws com.atlassian.plugin.PluginParseException
      */
     public String canLoad(final PluginArtifact pluginArtifact) throws PluginParseException
     {
         String pluginKey = null;
         for (final PluginFactory factory : pluginFactories)
         {
             pluginKey = factory.canCreate(pluginArtifact);
             if (pluginKey != null)
             {
                 break;
             }
         }
         return pluginKey;
     }
 
     @Override
     public void discardPlugin(final Plugin plugin)
     {
         // findMatchingDeploymentUnit throws rather than return null, so we won't remove(null)
         plugins.remove(findMatchingDeploymentUnit(plugin));
     }
 
     /**
      * Template method that can be used by a specific {@link PluginLoader} to
      * add information to a {@link Plugin} after it has been loaded.
      *
      * @param plugin a plugin that has been loaded
      * @since v2.2.0
      */
     protected Plugin postProcess(final Plugin plugin)
     {
         return plugin;
     }
 }