package com.atlassian.plugin;
   
   import com.atlassian.plugin.elements.ResourceDescriptor;
   import com.atlassian.plugin.elements.ResourceLocation;
   import com.atlassian.util.concurrent.Assertions;
   import com.google.common.base.Function;
   import com.google.common.base.Predicate;
   import com.google.common.collect.ImmutableList;
   import com.google.common.collect.Iterables;
  import com.google.common.collect.Lists;
  import org.dom4j.Element;
  
  import javax.annotation.Nullable;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import static com.atlassian.plugin.util.Assertions.notNull;
  import static com.google.common.collect.Iterables.filter;
  
  /**
   * An aggregate of all resource descriptors within the given plugin module or
   * plugin.
   *
   * @see com.atlassian.plugin.impl.AbstractPlugin#resources
   * @see com.atlassian.plugin.descriptors.AbstractModuleDescriptor#resources
   */
  public class Resources implements Resourced {
      public static final Resources EMPTY_RESOURCES = new Resources((Element) null);
  
      private final List<ResourceDescriptor> resourceDescriptors;
  
      /**
       * Parses the resource descriptors from the provided plugin XML element and
       * creates a Resources object containing them.
       * <p/>
       * If the module or plugin contains no resource elements, an empty Resources
       * object will be returned. This method will not return null.
       *
       * @param element the plugin or plugin module XML fragment which should not
       *                be null
       * @return a Resources object representing the resources in the plugin or
       * plugin module
       * @throws PluginParseException     if there are two resources with the same
       *                                  name and type in this element, or another parse error occurs
       * @throws IllegalArgumentException if the provided element is null
       */
      public static Resources fromXml(final Element element) throws PluginParseException, IllegalArgumentException {
          if (element == null) {
              throw new IllegalArgumentException("Cannot parse resources from null XML element");
          }
  
          @SuppressWarnings("unchecked")
          final List<Element> elements = element.elements("resource");
  
          final Set<ResourceDescriptor> templates = new HashSet<ResourceDescriptor>();
  
          for (final Element e : elements) {
              final ResourceDescriptor resourceDescriptor = new ResourceDescriptor(e);
  
              if (templates.contains(resourceDescriptor)) {
                  throw new PluginParseException("Duplicate resource with type '" + resourceDescriptor.getType() + "' and name '" + resourceDescriptor.getName() + "' found");
              }
  
              templates.add(resourceDescriptor);
          }
  
          return new Resources(element);
      }
  
      /**
       * Private constructor to create a Resources object from XML. Entry via fromXml.
       *
       * @param element
       */
      private Resources(final Element element) {
          if (element != null) {
              this.resourceDescriptors = Lists.newArrayList(Iterables.transform(element.elements("resource"), new Function<Element, ResourceDescriptor>() {
  
                  @Override
                  public ResourceDescriptor apply(@Nullable final Element e) {
                      return new ResourceDescriptor(e);
                  }
              }));
          } else {
              this.resourceDescriptors = Collections.emptyList();
          }
      }
  
      /**
       * Create a resource object with the given resource descriptors. The
       * provided list must not be null.
       *
       * @param resourceDescriptors the descriptors which are part of this
       *                            resources object
       * @throws IllegalArgumentException if the resourceDescriptors list is null
       * @deprecated Since 3.0.1, use {@link #fromXml(org.dom4j.Element)} instead. This will lazily create the
       * ResourceDescriptors from the Element, for a memory saving.
      */
     @Deprecated
     public Resources(final Iterable<ResourceDescriptor> resourceDescriptors) throws IllegalArgumentException {
         Assertions.notNull("Resources cannot be created with a null resources list. Pass empty list instead", resourceDescriptors);
         this.resourceDescriptors = ImmutableList.<ResourceDescriptor>builder().addAll(resourceDescriptors).build();
     }
 
     public List<ResourceDescriptor> getResourceDescriptors() {
         return resourceDescriptors;
     }
 
     /**
      * * @deprecated since 2.5.0 use {@link #getResourceDescriptors()} and
      * filter as required
      */
     @Deprecated
     public List<ResourceDescriptor> getResourceDescriptors(final String type) {
         return ImmutableList.<ResourceDescriptor>builder().addAll(filter(getResourceDescriptors(), new TypeFilter(type))).build();
     }
 
     public ResourceLocation getResourceLocation(final String type, final String name) {
         for (final ResourceDescriptor resourceDescriptor : getResourceDescriptors()) {
             if (resourceDescriptor.doesTypeAndNameMatch(type, name)) {
                 return resourceDescriptor.getResourceLocationForName(name);
             }
         }
         return null;
     }
 
     public ResourceDescriptor getResourceDescriptor(final String type, final String name) {
         for (final ResourceDescriptor resourceDescriptor : getResourceDescriptors()) {
             if (resourceDescriptor.getType().equalsIgnoreCase(type) && resourceDescriptor.getName().equalsIgnoreCase(name)) {
                 return resourceDescriptor;
             }
         }
         return null;
     }
 
     public static class TypeFilter implements Predicate<ResourceDescriptor> {
         private final String type;
 
         public TypeFilter(final String type) {
             this.type = notNull("type", type);
         }
 
         public boolean apply(final ResourceDescriptor input) {
             // TODO Auto-generated method stub
             return type.equals(input.getType());
         }
     }
 }