package com.atlassian.plugin.util;
   
   import com.atlassian.fugue.Option;
   import com.atlassian.plugin.Application;
   import com.atlassian.plugin.InstallationMode;
   import com.google.common.base.Function;
   import com.google.common.base.Objects;
   import com.google.common.base.Predicate;
   import com.google.common.collect.ImmutableList;
  import com.google.common.collect.Iterables;
  import org.apache.commons.lang.StringUtils;
  import org.dom4j.Element;
  
  import java.util.List;
  import java.util.Set;
  
  import static com.atlassian.fugue.Suppliers.alwaysTrue;
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  import static com.google.common.collect.Iterables.filter;
  import static com.google.common.collect.Iterables.transform;
  import static com.google.common.collect.Lists.newArrayList;
  
  /**
   * Represents a list of {@link ModuleRestrict}. This represents the restricts
   * as used in the plugin descriptor:
   * <code><br>
   * &nbsp;&nbsp;&lt;module key="module-key"><br>
   * &nbsp;&nbsp;&nbsp;&nbsp;&lt;restrict ...>...&lt;/restrict><br>
   * &nbsp;&nbsp;&nbsp;&nbsp;&lt;restrict ...>...&lt;/restrict><br>
   * &nbsp;&nbsp;&lt;/module>
   * </code>
   *
   * @since 3.0
   */
  final class ModuleRestricts {
      final Iterable<ModuleRestrict> restricts;
  
      private ModuleRestricts() {
          this(ImmutableList.<ModuleRestrict>of());
      }
  
      private ModuleRestricts(Iterable<ModuleRestrict> restricts) {
          this.restricts = ImmutableList.copyOf(restricts);
      }
  
      static ModuleRestricts parse(Element moduleElement) {
          final String applicationKeys = moduleElement.attributeValue("application");
          if (applicationKeys != null) {
              return parseApplicationsFromAttribute(applicationKeys);
          } else if (!moduleElement.elements("restrict").isEmpty()) {
              @SuppressWarnings("unchecked")
              final List<Element> restrict = moduleElement.elements("restrict");
              return parseApplicationsFromRestrictElements(restrict);
          } else {
              return new ModuleRestricts();
          }
      }
  
      private static ModuleRestricts parseApplicationsFromRestrictElements(List<Element> restrictElements) {
          return new ModuleRestricts(Iterables.transform(restrictElements, new Function<Element, ModuleRestrict>() {
              @Override
              public ModuleRestrict apply(Element restrictElement) {
                  final String application = restrictElement.attributeValue("application");
                  checkState(application != null, "No application defined for 'restrict' element.");
                  return new ModuleRestrict(application, parseInstallationMode(restrictElement), parseVersionRange(restrictElement));
              }
          }));
      }
  
      private static Option<InstallationMode> parseInstallationMode(Element restrictElement) {
          return InstallationMode.of(restrictElement.attributeValue("mode"));
      }
  
      private static VersionRange parseVersionRange(Element restrictElement) {
          final String version = restrictElement.attributeValue("version");
          if (version != null) {
              return VersionRange.parse(version);
          } else {
              final List<Element> versionElements = restrictElement.elements("version");
              if (!versionElements.isEmpty()) {
                  VersionRange range = VersionRange.empty();
                  for (Element versionElement : versionElements) {
                      range = range.or(VersionRange.parse(versionElement.getText()));
                  }
                  return range;
              } else {
                  return VersionRange.all();
              }
          }
      }
  
      private static ModuleRestricts parseApplicationsFromAttribute(String applicationKeys) {
          final String[] keys = applicationKeys.split("\\s*,[,\\s]*");
          final Iterable<ModuleRestrict> restricts = transform(filter(newArrayList(keys), new IsNotBlankPredicate()), new Function<String, ModuleRestrict>() {
              @Override
              public ModuleRestrict apply(String app) {
                  return new ModuleRestrict(app);
              }
         });
 
         return new ModuleRestricts(restricts);
     }
 
     public boolean isValidFor(Set<Application> applications, InstallationMode mode) {
         if (Iterables.isEmpty(restricts)) {
             return true;
         }
 
         for (Application application : applications) {
             if (Iterables.any(restricts, new RestrictMatchesApplication(application, mode))) {
                 return true;
             }
         }
         return false;
     }
 
     @Override
     public String toString() {
         return restricts.toString();
     }
 
     static final class ModuleRestrict {
         final String application;
         final Option<InstallationMode> mode;
         final VersionRange version;
 
         ModuleRestrict(String application) {
             this(application, Option.<InstallationMode>none());
         }
 
         ModuleRestrict(String application, Option<InstallationMode> mode) {
             this(application, mode, VersionRange.all());
         }
 
         ModuleRestrict(String application, Option<InstallationMode> mode, VersionRange version) {
             this.application = checkNotNull(application);
             this.mode = checkNotNull(mode);
             this.version = checkNotNull(version);
         }
 
         @Override
         public String toString() {
             return Objects.toStringHelper("restrict")
                     .add("application", application)
                     .add("mode", mode)
                     .add("range", version)
                     .toString();
         }
     }
 
     private static final class IsNotBlankPredicate implements Predicate<String> {
         @Override
         public boolean apply(String input) {
             return StringUtils.isNotBlank(input);
         }
     }
 
     private static final class RestrictMatchesApplication implements Predicate<ModuleRestrict> {
         private final Application app;
         private final InstallationMode installationMode;
 
         public RestrictMatchesApplication(Application app, InstallationMode installationMode) {
             this.app = checkNotNull(app);
             this.installationMode = checkNotNull(installationMode);
         }
 
         @Override
         public boolean apply(ModuleRestrict restrict) {
             return restrict.application.equals(app.getKey())
                     && isInstallModeValid(restrict.mode)
                     && restrict.version.isInRange(app.getVersion());
         }
 
         private boolean isInstallModeValid(Option<InstallationMode> mode) {
             return mode.fold(alwaysTrue(), new Function<InstallationMode, Boolean>() {
                 @Override
                 public Boolean apply(InstallationMode m) {
                     return m.equals(installationMode);
                 }
             });
         }
     }
 }