package com.atlassian.plugin.schema.impl;
   
   import com.atlassian.plugin.ModuleDescriptor;
   import com.atlassian.plugin.ModuleDescriptorFactory;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginParseException;
   import com.atlassian.plugin.descriptors.AbstractModuleDescriptor;
   import com.atlassian.plugin.descriptors.CannotDisable;
   import com.atlassian.plugin.module.ContainerManagedPlugin;
  import com.atlassian.plugin.module.ModuleFactory;
  import com.atlassian.plugin.osgi.external.ListableModuleDescriptorFactory;
  import com.atlassian.plugin.osgi.factory.OsgiPlugin;
  import com.atlassian.plugin.schema.descriptor.DescribedModuleDescriptorFactory;
  import com.atlassian.plugin.schema.spi.DocumentBasedSchema;
  import com.atlassian.plugin.schema.spi.Schema;
  import com.atlassian.plugin.schema.spi.SchemaFactory;
  import com.atlassian.plugin.schema.spi.SchemaTransformer;
  import com.atlassian.plugin.util.resource.AlternativeResourceLoader;
  import com.atlassian.util.concurrent.NotNull;
  import com.google.common.base.Function;
  import com.google.common.base.Suppliers;
  import com.google.common.collect.ImmutableList;
  import org.dom4j.Element;
  import org.osgi.framework.BundleContext;
  
  import java.io.InputStream;
  import java.net.URL;
  import java.util.List;
  
  import static com.atlassian.fugue.Option.option;
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  import static com.google.common.collect.Iterables.transform;
  
  /**
   * Descriptor that allows described module descriptor factories to be configured in XML.  Main value
   * is the ability to reuse the name and description of the module descriptor configuration.
   */
  @CannotDisable
  public final class DescribedModuleTypeModuleDescriptor extends AbstractModuleDescriptor<DescribedModuleDescriptorFactory>
  {
      private static final String[] PUBLIC_INTERFACES = new String[] {
              ModuleDescriptorFactory.class.getName(),
              ListableModuleDescriptorFactory.class.getName(),
              DescribedModuleDescriptorFactory.class.getName()
      };
  
      private String schemaFactoryClassName;
      private String type;
      private String schemaTransformerClassName;
      private String maxOccurs;
      private Iterable<String> requiredPermissions;
      private Iterable<String> optionalPermissions;
  
      public DescribedModuleTypeModuleDescriptor(ModuleFactory moduleFactory)
      {
          super(moduleFactory);
      }
  
      @Override
      public void init(@NotNull Plugin plugin, @NotNull Element element) throws PluginParseException
      {
          checkState(plugin instanceof OsgiPlugin, "Described module types can only be declared in OSGi Plugins, %s is not such a plugin", plugin.getKey());
  
          super.init(plugin, element);
  
          this.type = getOptionalAttribute(element, "type", getKey());
          this.schemaFactoryClassName = getOptionalAttribute(element, "schema-factory-class", null);
          this.schemaTransformerClassName = getOptionalAttribute(element, "schema-transformer-class", null);
          this.maxOccurs = getOptionalAttribute(element, "max-occurs", "unbounded");
          this.requiredPermissions = getPermissions(element.element("required-permissions"));
          this.optionalPermissions = getPermissions(element.element("optional-permissions"));
      }
  
      private static Iterable<String> getPermissions(Element element)
      {
          return option(element).fold(
                  Suppliers.ofInstance(ImmutableList.<String>of()),
                  new Function<Element, Iterable<String>>()
                  {
                      @Override
                      public Iterable<String> apply(Element e)
                      {
                          return transform(getElements(e, "permission"), new Function<Element, String>()
                          {
                              @Override
                              public String apply(Element input)
                              {
                                  return input.getTextTrim();
                              }
                          });
                      }
                  });
      }
  
      @SuppressWarnings("unchecked")
      private static List<Element> getElements(Element element, String name)
      {
          return element.elements(name);
     }
 
     @Override
     public void enabled()
     {
         checkState(plugin instanceof OsgiPlugin, "Described module types can only be declared in OSGi Plugins, %s is not such a plugin", plugin.getKey());
 
         super.enabled();
 
         final SchemaTransformer schemaTransformer = schemaTransformerClassName != null
                 ? create(findClass(schemaTransformerClassName, SchemaTransformer.class))
                 : SchemaTransformer.IDENTITY;
 
         final SchemaFactory schemaFactory = schemaFactoryClassName != null
                 ? create(findClass(schemaFactoryClassName, SchemaFactory.class))
                 : buildSingleton(DocumentBasedSchema.builder(type)
                 .setResourceLoader(new AlternativePluginResourceLoader(plugin))
                 .setName(getName() != null ? getName() : getKey())
                 .setDescription(getDescription() != null ? getDescription() : "")
                 .setTransformer(schemaTransformer)
                 .setMaxOccurs(maxOccurs)
                 .setRequiredPermissions(requiredPermissions)
                 .setOptionalPermissions(optionalPermissions)
                 .build()
         );
 
         @SuppressWarnings("unchecked")
         final DescribedModuleDescriptorFactory factory = new DescribedModuleTypeDescribedModuleDescriptorFactory(
                 (ContainerManagedPlugin) plugin,
                 type,
                 findClass(moduleClassName, ModuleDescriptor.class),
                 schemaFactory);
 
         getBundleContext().registerService(PUBLIC_INTERFACES, factory, null);
     }
 
     private BundleContext getBundleContext()
     {
         return ((OsgiPlugin) plugin).getBundle().getBundleContext();
     }
 
     private <T> T create(Class<? extends T> type)
     {
         return ((ContainerManagedPlugin) plugin).getContainerAccessor().createBean(type);
     }
 
     private <T> Class<? extends T> findClass(String className, Class<T> castTo)
     {
         checkNotNull(className);
         Class<T> clazz;
         try
         {
             clazz = plugin.loadClass(className, getClass());
         }
         catch (ClassNotFoundException e)
         {
             throw new PluginParseException("Unable to find class " + className);
         }
         return clazz.asSubclass(castTo);
     }
 
     @Override
     public DescribedModuleDescriptorFactory getModule()
     {
         return moduleFactory.createModule(moduleClassName, this);
     }
 
     private SchemaFactory buildSingleton(final Schema schema)
     {
         return new SchemaFactory()
         {
             @Override
             public Schema getSchema()
             {
                 return schema;
             }
         };
     }
 
     public static String getOptionalAttribute(Element e, String name, Object defaultValue)
     {
         String value = e.attributeValue(name);
         return value != null ? value :
                 defaultValue != null ? defaultValue.toString() : null;
     }
 
     private static final class AlternativePluginResourceLoader implements AlternativeResourceLoader
     {
         private final Plugin plugin;
 
         public AlternativePluginResourceLoader(final Plugin plugin)
         {
             this.plugin = checkNotNull(plugin);
         }
 
         @Override
         public URL getResource(final String path)
         {
             return plugin.getResource(path);
         }
 
         @Override
         public InputStream getResourceAsStream(final String name)
         {
             return plugin.getResourceAsStream(name);
         }
     }
 }