package com.atlassian.plugin.osgi.factory;
   
   import com.atlassian.plugin.Application;
   import com.atlassian.plugin.JarPluginArtifact;
   import com.atlassian.plugin.ModuleDescriptorFactory;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginArtifact;
   import com.atlassian.plugin.PluginInformation;
   import com.atlassian.plugin.PluginParseException;
  import com.atlassian.plugin.PluginPermission;
  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.container.OsgiPersistentCache;
  import com.atlassian.plugin.osgi.factory.transform.DefaultPluginTransformer;
  import com.atlassian.plugin.osgi.factory.transform.PluginTransformationException;
  import com.atlassian.plugin.osgi.factory.transform.PluginTransformer;
  import com.atlassian.plugin.osgi.factory.transform.model.SystemExports;
  import com.atlassian.plugin.parsers.DescriptorParser;
  import com.google.common.base.Predicate;
  import com.google.common.collect.ImmutableSet;
  import com.google.common.collect.Ranges;
  import org.apache.commons.io.IOUtils;
  import org.osgi.framework.Constants;
  import org.osgi.util.tracker.ServiceTracker;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Set;
  import java.util.jar.Manifest;
  
  import static com.atlassian.plugin.osgi.util.OsgiHeaderUtil.getAttributeWithoutValidation;
  import static com.atlassian.plugin.osgi.util.OsgiHeaderUtil.getNonEmptyAttribute;
  import static com.atlassian.plugin.osgi.util.OsgiHeaderUtil.getValidatedAttribute;
  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 OsgiPluginFactory extends AbstractPluginFactory
  {
      private static final Logger log = LoggerFactory.getLogger(OsgiPluginFactory.class);
  
      public interface PluginTransformerFactory
      {
          PluginTransformer newPluginTransformer(OsgiPersistentCache cache, SystemExports systemExports, Set<Application> applicationKeys, String pluginDescriptorPath, OsgiContainerManager osgi);
      }
  
      public static class DefaultPluginTransformerFactory implements PluginTransformerFactory
      {
          public PluginTransformer newPluginTransformer(OsgiPersistentCache cache, SystemExports systemExports, Set<Application> applicationKeys, String pluginDescriptorPath, OsgiContainerManager osgi)
          {
              return new DefaultPluginTransformer(cache, systemExports, applicationKeys, pluginDescriptorPath, osgi);
          }
      }
  
      private final OsgiContainerManager osgi;
      private final String pluginDescriptorFileName;
      private final PluginEventManager pluginEventManager;
      private final Set<Application> applications;
      private final OsgiPersistentCache persistentCache;
      private final PluginTransformerFactory pluginTransformerFactory;
  
      private volatile PluginTransformer pluginTransformer;
  
      private final OsgiChainedModuleDescriptorFactoryCreator osgiChainedModuleDescriptorFactoryCreator;
  
      /**
       * Default constructor
       */
      public OsgiPluginFactory(String pluginDescriptorFileName, Set<Application> applications, OsgiPersistentCache persistentCache, final OsgiContainerManager osgi, PluginEventManager pluginEventManager)
      {
          this(pluginDescriptorFileName, applications, persistentCache, osgi, pluginEventManager, new DefaultPluginTransformerFactory());
      }
  
      /**
       * Constructor for implementations that want to override the DefaultPluginTransformer with a custom implementation
       */
      public OsgiPluginFactory(String pluginDescriptorFileName, Set<Application> applications, OsgiPersistentCache persistentCache, final OsgiContainerManager osgi, PluginEventManager pluginEventManager, PluginTransformerFactory pluginTransformerFactory)
      {
          super(new OsgiPluginXmlDescriptorParserFactory(), applications);
          this.pluginDescriptorFileName = checkNotNull(pluginDescriptorFileName, "Plugin descriptor is required");
          this.osgi = checkNotNull(osgi, "The OSGi container is required");
          this.applications = checkNotNull(applications, "Applications is required!");
          this.persistentCache = checkNotNull(persistentCache, "The osgi persistent cache is required");
          this.pluginEventManager = checkNotNull(pluginEventManager, "The plugin event manager is required");
          this.pluginTransformerFactory = checkNotNull(pluginTransformerFactory, "The plugin transformer factory is required");
          this.osgiChainedModuleDescriptorFactoryCreator = new OsgiChainedModuleDescriptorFactoryCreator(new OsgiChainedModuleDescriptorFactoryCreator.ServiceTrackerFactory()
          {
              public ServiceTracker create(String className)
             {
                 return osgi.getServiceTracker(className);
             }
         });
     }
 
     private PluginTransformer getPluginTransformer()
     {
         if (pluginTransformer == null)
         {
             String exportString = (String) osgi.getBundles()[0].getHeaders()
                     .get(Constants.EXPORT_PACKAGE);
             SystemExports exports = new SystemExports(exportString);
             pluginTransformer = pluginTransformerFactory.newPluginTransformer(persistentCache, exports, applications, pluginDescriptorFileName, osgi);
         }
         return pluginTransformer;
     }
 
     public String canCreate(PluginArtifact pluginArtifact) throws PluginParseException
     {
         if (hasDescriptor(checkNotNull(pluginArtifact)))
         {
             return getPluginKeyFromDescriptor(checkNotNull(pluginArtifact));
         }
         else // no descriptor, pure OSGi bundle
         {
             return getPluginKeyFromManifest(pluginArtifact);
         }
     }
 
     @Override
     protected InputStream getDescriptorInputStream(PluginArtifact pluginArtifact)
     {
         return pluginArtifact.getResourceAsStream(pluginDescriptorFileName);
     }
 
     @Override
     protected Predicate<Integer> isValidPluginsVersion()
     {
         return Ranges.singleton(Plugin.VERSION_2);
     }
 
     /**
      * @param pluginArtifact The plugin artifact
      * @return The plugin key if a manifest is present and contains {@link OsgiPlugin#ATLASSIAN_PLUGIN_KEY} and
      * {@link Constants#BUNDLE_VERSION}
      */
     private String getPluginKeyFromManifest(PluginArtifact pluginArtifact)
     {
         final Manifest mf = getManifest(pluginArtifact);
         if (mf != null)
         {
             final String key = mf.getMainAttributes().getValue(OsgiPlugin.ATLASSIAN_PLUGIN_KEY);
             final String version = mf.getMainAttributes().getValue(Constants.BUNDLE_VERSION);
             if (key != null)
             {
                 if (version != null)
                 {
                     return key;
                 }
                 else
                 {
                     log.warn("Found plugin key '" + key + "' in the manifest but no bundle version, so it can't be loaded as an OsgiPlugin");
                 }
             }
         }
         return null;
     }
 
     private Manifest getManifest(PluginArtifact pluginArtifact)
     {
         InputStream descriptorClassStream = pluginArtifact.getResourceAsStream("META-INF/MANIFEST.MF");
         if (descriptorClassStream != null)
         {
             try
             {
                 return new Manifest(descriptorClassStream);
             }
             catch (IOException e)
             {
                 log.error("Cannot read manifest from plugin artifact " + pluginArtifact.getName(), e);
             }
             finally
             {
                 IOUtils.closeQuietly(descriptorClassStream);
             }
         }
         return null;
     }
 
     /**
      * 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 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
     {
         checkNotNull(pluginArtifact, "The plugin deployment unit is required");
         checkNotNull(moduleDescriptorFactory, "The module descriptor factory is required");
 
         Plugin plugin = null;
         InputStream pluginDescriptor = null;
         try
         {
             pluginDescriptor = pluginArtifact.getResourceAsStream(pluginDescriptorFileName);
             if (pluginDescriptor != null)
             {
                 ModuleDescriptorFactory combinedFactory = getChainedModuleDescriptorFactory(moduleDescriptorFactory, pluginArtifact);
                 DescriptorParser parser = descriptorParserFactory.getInstance(pluginDescriptor, applications);
 
                 final PluginArtifact artifactToInstall;
 
                 // only transform the artifact if no plugin key is found in the manifest
                 final String pluginKeyFromManifest = getPluginKeyFromManifest(pluginArtifact);
                 if (pluginKeyFromManifest == null)
                 {
                     log.debug("Plugin key NOT found in manifest at entry {}, undergoing transformation", OsgiPlugin.ATLASSIAN_PLUGIN_KEY);
                     artifactToInstall = createOsgiPluginJar(pluginArtifact);
                 }
                 else
                 {
                     log.debug("Plugin key found in manifest at entry {}, skipping transformation for '{}'", OsgiPlugin.ATLASSIAN_PLUGIN_KEY, pluginKeyFromManifest);
                     artifactToInstall = pluginArtifact;
                 }
 
                 final Plugin osgiPlugin = new OsgiPlugin(parser.getKey(), osgi, artifactToInstall, pluginArtifact, pluginEventManager);
 
                 // Temporarily configure plugin until it can be properly installed
                 plugin = parser.configurePlugin(combinedFactory, osgiPlugin);
             }
             else
             {
                 Manifest mf = getManifest(pluginArtifact);
                 plugin = extractOsgiPlugin(pluginArtifact, mf, osgi, pluginEventManager);
                 plugin.setPluginInformation(extractOsgiPluginInformation(mf));
             }
         }
         catch (PluginTransformationException ex)
         {
             return reportUnloadablePlugin(pluginArtifact.toFile(), ex);
         }
         finally
         {
             IOUtils.closeQuietly(pluginDescriptor);
         }
         return plugin;
     }
 
     private static Plugin extractOsgiPlugin(PluginArtifact pluginArtifact, Manifest mf, final OsgiContainerManager osgi, final PluginEventManager pluginEventManager)
     {
         Plugin plugin;
         String pluginKey = getNonEmptyAttribute(mf, OsgiPlugin.ATLASSIAN_PLUGIN_KEY);
         String bundleName = getAttributeWithoutValidation(mf, Constants.BUNDLE_NAME);
 
         plugin = new OsgiPlugin(pluginKey, osgi, pluginArtifact, pluginArtifact, pluginEventManager);
         plugin.setKey(pluginKey);
         plugin.setPluginsVersion(2);
         plugin.setName(bundleName);
         return plugin;
     }
 
     private PluginInformation extractOsgiPluginInformation(final Manifest manifest) {
         String pluginVersion = getValidatedAttribute(manifest, Constants.BUNDLE_VERSION);
         String vendorName = getAttributeWithoutValidation(manifest, Constants.BUNDLE_VENDOR);
         String bundleDescription = getAttributeWithoutValidation(manifest, Constants.BUNDLE_DESCRIPTION);
         PluginInformation info = new PluginInformation();
         info.setVersion(pluginVersion);
         info.setDescription(bundleDescription);
         info.setVendorName(vendorName);
         info.setPermissions(ImmutableSet.of(PluginPermission.EXECUTE_JAVA)); // OSGi plugins require execute Java.
         return info;
     }
 
 
     /**
      * 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 PluginArtifact createOsgiPluginJar(PluginArtifact pluginArtifact)
     {
         File transformedFile = getPluginTransformer().transform(pluginArtifact, osgi.getHostComponentRegistrations());
         // A transformed jar is always allows reference, because the jar is sitting in a transform cache somewhere.
         // A PluginTransformer implementation could conceivably break this, but it would be broken to do so.
         return new JarPluginArtifact(transformedFile, true);
     }
 
     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;
     }
 }