package com.atlassian.plugin.osgi.factory;
   
   import com.atlassian.plugin.Application;
   import com.atlassian.plugin.ModuleDescriptorFactory;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginArtifact;
   import com.atlassian.plugin.PluginParseException;
   import com.atlassian.plugin.event.PluginEventManager;
   import com.atlassian.plugin.factories.AbstractPluginFactory;
  import com.atlassian.plugin.impl.UnloadablePlugin;
  import com.atlassian.plugin.osgi.container.OsgiContainerManager;
  import com.atlassian.plugin.osgi.factory.transform.PluginTransformationException;
  import com.atlassian.plugin.parsers.DescriptorParser;
  import com.google.common.base.Predicate;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang.Validate;
  import org.osgi.util.tracker.ServiceTracker;
  
  import java.io.File;
  import java.io.InputStream;
  import java.util.Set;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  
  /**
   * Plugin loader that starts an OSGi container and loads plugins into it, wrapped as OSGi bundles.  Supports
   * <ul>
   * <li>Dynamic loading of module descriptors via OSGi services</li>
   * <li>Delayed enabling until the plugin container is active</li>
   * <li>XML or Jar manifest configuration</li>
   * </ul>
   */
  public final class RemotablePluginFactory extends AbstractPluginFactory
  {
      private final OsgiContainerManager osgi;
      private final String pluginDescriptorFileName;
      private final PluginEventManager pluginEventManager;
  
      private final OsgiChainedModuleDescriptorFactoryCreator osgiChainedModuleDescriptorFactoryCreator;
  
      /**
       * Constructor for implementations that want to override the DefaultPluginTransformer with a custom implementation
       */
      public RemotablePluginFactory(String pluginDescriptorFileName, Set<Application> applications, final OsgiContainerManager osgi, PluginEventManager pluginEventManager)
      {
          super(new OsgiPluginXmlDescriptorParserFactory(), applications);
          this.pluginDescriptorFileName = checkNotNull(pluginDescriptorFileName, "Plugin descriptor is required");
          this.osgi = checkNotNull(osgi, "The OSGi container is required");
          this.pluginEventManager = checkNotNull(pluginEventManager, "The plugin event manager is required");
          this.osgiChainedModuleDescriptorFactoryCreator = new OsgiChainedModuleDescriptorFactoryCreator(new OsgiChainedModuleDescriptorFactoryCreator.ServiceTrackerFactory()
          {
              public ServiceTracker create(String className)
              {
                  return osgi.getServiceTracker(className);
              }
          });
      }
  
  
      @Override
      protected InputStream getDescriptorInputStream(PluginArtifact pluginArtifact)
      {
          return pluginArtifact.getResourceAsStream(pluginDescriptorFileName);
      }
  
      @Override
      protected Predicate<Integer> isValidPluginsVersion()
      {
          return new Predicate<Integer>()
          {
  
              @Override
              public boolean apply(Integer version)
              {
                  return version == 3;
              }
          };
      }
  
      /**
       * Deploys the plugin artifact.  The artifact will only undergo transformation if a plugin descriptor can be found
       * and the "Atlassian-Plugin-Key" value is not already defined in the manifest.
       *
       * @param pluginArtifact the plugin artifact to deploy
       * @param moduleDescriptorFactory The factory for plugin modules
       * @return The instantiated and populated plugin
       * @throws com.atlassian.plugin.PluginParseException If the descriptor cannot be parsed
       * @throws IllegalArgumentException If the plugin descriptor isn't found, and the plugin key and bundle version aren't
       * specified in the manifest
       * @since 2.2.0
       */
      public Plugin create(PluginArtifact pluginArtifact, ModuleDescriptorFactory moduleDescriptorFactory) throws PluginParseException
      {
          Validate.notNull(pluginArtifact, "The plugin deployment unit is required");
          Validate.notNull(moduleDescriptorFactory, "The module descriptor factory is required");
  
          Plugin plugin = null;
          InputStream pluginDescriptor = null;
          try
         {
             pluginDescriptor = pluginArtifact.getResourceAsStream(pluginDescriptorFileName);
             if (pluginDescriptor != null)
             {
                 final ModuleDescriptorFactory combinedFactory = getChainedModuleDescriptorFactory(moduleDescriptorFactory, pluginArtifact);
                 final DescriptorParser parser = descriptorParserFactory.getInstance(pluginDescriptor, applications.toArray(new Application[applications.size()]));
 
                 final String pluginKey = parser.getKey();
                 final Plugin osgiPlugin = new OsgiPlugin(pluginKey, osgi, pluginArtifact, pluginArtifact, pluginEventManager);
 
                 // Temporarily configure plugin until it can be properly installed
                 plugin = parser.configurePlugin(combinedFactory, osgiPlugin);
             }
             else
             {
                 throw new PluginParseException("Attempt to create Remotable plugin without a plugin descriptor!");
             }
         }
         catch (PluginTransformationException ex)
         {
             return reportUnloadablePlugin(pluginArtifact.toFile(), ex);
         }
         finally
         {
             IOUtils.closeQuietly(pluginDescriptor);
         }
         return plugin;
     }
 
     /**
      * Get a chained module descriptor factory that includes any dynamically available descriptor factories
      *
      * @param originalFactory The factory provided by the host application
      * @param pluginArtifact
      * @return The composite factory
      */
     private ModuleDescriptorFactory getChainedModuleDescriptorFactory(ModuleDescriptorFactory originalFactory, final PluginArtifact pluginArtifact)
     {
         return osgiChainedModuleDescriptorFactoryCreator.create(new OsgiChainedModuleDescriptorFactoryCreator.ResourceLocator()
         {
             public boolean doesResourceExist(String name)
             {
                 return pluginArtifact.doesResourceExist(name);
             }
         }, originalFactory);
     }
 
     private Plugin reportUnloadablePlugin(File file, Exception e)
     {
         log.error("Unable to load plugin: " + file, e);
 
         UnloadablePlugin plugin = new UnloadablePlugin();
         plugin.setErrorText("Unable to load plugin: " + e.getMessage());
         return plugin;
     }
 }