package com.atlassian.plugin.osgi.spring;
   
   import java.lang.reflect.Field;
   import java.lang.reflect.Method;
   import java.util.Map;
   
   import javax.annotation.Nullable;
   
   import com.atlassian.plugin.event.PluginEventListener;
  import com.atlassian.plugin.event.PluginEventManager;
  import com.atlassian.plugin.event.events.PluginFrameworkStartedEvent;
  
  import com.google.common.base.Throwables;
  
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.BundleEvent;
  import org.osgi.framework.BundleListener;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.CachedIntrospectionResults;
  import org.springframework.beans.factory.DisposableBean;
  import org.springframework.beans.factory.InitializingBean;
  
  /**
   * This class ensures that all classes in OSGi bundles can be cached by
   * {@link org.springframework.beans.CachedIntrospectionResults}.
   *
   * @since 3.2.17
   */
  public class MarkBundleClassesCacheableListener implements BundleListener, InitializingBean, DisposableBean
  {
      private static final Logger log = LoggerFactory.getLogger(MarkBundleClassesCacheableListener.class);
  
      private final BundleContext bundleContext;
      private final PluginEventManager pluginEventManager;
  
      private final Class<?> bundleImplClass;
      private final Method getModule;
      private final Class<?> moduleImplClass;
      private final Method getClassLoader;
  
      private final Object lock = new Object();
      private boolean active;
  
      public MarkBundleClassesCacheableListener(BundleContext bundleContext, PluginEventManager pluginEventManager)
      {
          this.bundleContext = bundleContext;
          this.pluginEventManager = pluginEventManager;
  
          Class<?> bundleImplClass = null;
          Method getModule = null;
          Class<?> moduleImplClass = null;
          Method getClassLoader = null;
          try
          {
              bundleImplClass = Bundle.class.getClassLoader().loadClass("org.apache.felix.framework.BundleImpl");
              getModule = bundleImplClass.getDeclaredMethod("getCurrentModule");
              getModule.setAccessible(true);
  
              moduleImplClass = Bundle.class.getClassLoader().loadClass("org.apache.felix.framework.ModuleImpl");
              getClassLoader = moduleImplClass.getDeclaredMethod("getClassLoader");
              getClassLoader.setAccessible(true);
  
              active = Boolean.getBoolean("atlassian.enable.spring.strong.cache.bean.metadata");
          }
          catch (Exception e)
          {
              log.warn("Reflection failed. Performance may suffer.", e);
          }
          this.bundleImplClass = bundleImplClass;
          this.getModule = getModule;
          this.moduleImplClass = moduleImplClass;
          this.getClassLoader = getClassLoader;
      }
  
      @Override
      public void afterPropertiesSet()
      {
          bundleContext.addBundleListener(this);
          pluginEventManager.register(this);
          for (Bundle bundle : bundleContext.getBundles())
          {
              if (bundle.getState() == Bundle.ACTIVE)
              {
                  maybeAcceptClassLoader(bundle);
              }
          }
      }
  
      @Override
      public void destroy()
      {
          synchronized (lock)
          {
              for (Bundle bundle : bundleContext.getBundles())
              {
                  if (bundle.getState() == Bundle.ACTIVE)
                  {
                     maybeClearClassLoader(bundle);
                 }
             }
             active = false;
         }
         // Any events arriving at this stage are ignored as active=false
         pluginEventManager.unregister(this);
         bundleContext.removeBundleListener(this);
     }
 
     @Override
     public void bundleChanged(BundleEvent event)
     {
         switch (event.getType()) {
             case BundleEvent.STARTED: {
                 maybeAcceptClassLoader(event.getBundle());
                 break;
             }
             case BundleEvent.STOPPED: {
                 maybeClearClassLoader(event.getBundle());
                 break;
             }
             default:
                 break;
         }
     }
 
     private void maybeAcceptClassLoader(Bundle bundle)
     {
         synchronized (lock)
         {
             ClassLoader bundleClassLoader = getBundleClassLoader(bundle);
             if (bundleClassLoader != null)
             {
                 CachedIntrospectionResults.acceptClassLoader(bundleClassLoader);
             }
         }
 
     }
 
     private void maybeClearClassLoader(Bundle bundle)
     {
         synchronized (lock)
         {
             ClassLoader bundleClassLoader = getBundleClassLoader(bundle);
             if (bundleClassLoader != null)
             {
                 CachedIntrospectionResults.clearClassLoader(bundleClassLoader);
             }
         }
     }
 
     @Nullable
     private ClassLoader getBundleClassLoader(Bundle bundle)
     {
         if (active)
         {
             try
             {
                 // This reflection should be replaced with
                 // bundle.adapt(BundleWiring.class).getClassLoader() once available
                 if (bundleImplClass == bundle.getClass())
                 {
                     final Object module = getModule.invoke(bundle);
                     if (moduleImplClass == module.getClass())
                     {
                         return (ClassLoader) getClassLoader.invoke(module);
                     }
                 }
             }
             catch (Exception e)
             {
                 log.warn("Failed to retrieve class loader for bundle '{}'", bundle.getSymbolicName(), e);
             }
         }
         return null;
     }
 
     @PluginEventListener
     public void onPluginEnabled(PluginFrameworkStartedEvent event)
     {
         if(Boolean.getBoolean("atlassian.enable.spring.strong.cache.bean.metadata.flush"))
         {
             try
             {
                 final Field classCacheField = CachedIntrospectionResults.class.getDeclaredField("classCache");
                 classCacheField.setAccessible(true);
                 Map classCache = (Map) classCacheField.get(null);
 
                 // Flush class cache after plugin framework has started in
                 // order to free up entries only needed during start-up
                 classCache.clear();
             }
             catch (Exception e)
             {
                 Throwables.propagate(e);
             }
         }
     }
 }