package org.apache.maven.plugins.enforcer;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.util.Iterator;
  
  import org.apache.maven.enforcer.rule.api.EnforcerRule;
  import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
  import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
  import org.apache.maven.model.Activation;
  import org.apache.maven.model.ActivationOS;
  import org.apache.maven.model.Profile;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.profiles.activation.OperatingSystemProfileActivator;
  import org.codehaus.plexus.util.Os;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * This rule checks that the OS is allowed by combinations of family, name, version and cpu architecture. The behavior
   * is exactly the same as the Maven Os profile activation so the same values are allowed here.
   *
   * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
   * @version $Id: RequireOS.java 1345332 2012-06-01 20:14:13Z rfscholte $
   */
  public class RequireOS
      extends AbstractStandardEnforcerRule
  {
  
      /**
       * The OS family type desired<br />
       * Possible values:
       * <ul>
       * <li>dos</li>
       * <li>mac</li>
       * <li>netware</li>
       * <li>os/2</li>
       * <li>tandem</li>
       * <li>unix</li>
       * <li>windows</li>
       * <li>win9x</li>
       * <li>z/os</li>
       * <li>os/400</li>
       * </ul>
       */
      public String family = null;
  
      /** The OS name desired. */
      public String name = null;
  
      /** The OS version desired. */
      public String version = null;
  
      /** The OS architecture desired. */
      public String arch = null;
  
      /** Specify an optional message to the user if the rule fails. */
      public String message = "";
  
      /** Display detected OS information. */
      public boolean display = false;
  
      /**
       * Instantiates a new RequireOS.
       */
      public RequireOS()
      {
  
      }
  
      /*
       * (non-Javadoc)
       *
       * @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
       */
      public void execute( EnforcerRuleHelper helper )
          throws EnforcerRuleException
      {
  
          displayOSInfo( helper.getLog(), display );
  
          if ( allParamsEmpty() )
          {
             throw new EnforcerRuleException( "All parameters can not be empty. You must pick at least one of (family, name, version, arch) or use -Denforcer.os.display=true to see the current OS information." );
         }
 
         if ( isValidFamily( this.family ) )
         {
             if ( !isAllowed() )
             {
                 if ( StringUtils.isEmpty( message ) )
                 {
                     message =
                         ( "OS Arch: " + Os.OS_ARCH + " Family: " + Os.OS_FAMILY + " Name: " + Os.OS_NAME +
                             " Version: " + Os.OS_VERSION + " is not allowed by" +
                             ( arch != null ? " Arch=" + arch : "" ) + ( family != null ? " Family=" + family : "" ) +
                             ( name != null ? " Name=" + name : "" ) + ( version != null ? " Version=" + version : "" ) );
                 }
                 throw new EnforcerRuleException( message );
             }
         }
         else
         {
             StringBuilder buffer = new StringBuilder( 50 );
             Iterator iter = Os.getValidFamilies().iterator();
             while ( iter.hasNext() )
             {
                 buffer.append( iter.next() );
                 buffer.append( ", " );
             }
             String help = StringUtils.stripEnd( buffer.toString().trim(), "." );
             throw new EnforcerRuleException( "Invalid Family type used. Valid family types are: " + help );
         }
     }
 
     /**
      * Log the current OS information.
      *
      * @param log the log
      * @param info the info
      */
     public void displayOSInfo( Log log, boolean info )
     {
         String string =
             "OS Info: Arch: " + Os.OS_ARCH + " Family: " + Os.OS_FAMILY + " Name: " + Os.OS_NAME + " Version: " +
                 Os.OS_VERSION;
 
         if ( !info )
         {
             log.debug( string );
         }
         else
         {
             log.info( string );
         }
     }
 
     /**
      * Helper method to determine if the current OS is allowed based on the injected values for family, name, version
      * and arch.
      *
      * @return true if the version is allowed.
      */
     public boolean isAllowed()
     {
         OperatingSystemProfileActivator activator = new OperatingSystemProfileActivator();
 
         return activator.isActive( createProfile() );
     }
 
     /**
      * Helper method to check that at least one of family, name, version or arch is set.
      *
      * @return true if all parameters are empty.
      */
     public boolean allParamsEmpty()
     {
         return ( StringUtils.isEmpty( family ) && StringUtils.isEmpty( arch ) && StringUtils.isEmpty( name ) && StringUtils.isEmpty( version ) );
 
     }
 
     /**
      * Creates a Profile object that contains the activation information.
      *
      * @return a properly populated profile to be used for OS validation.
      */
     private Profile createProfile()
     {
         Profile profile = new Profile();
         profile.setActivation( createActivation() );
         return profile;
     }
 
     /**
      * Creates an Activation object that contains the ActivationOS information.
      *
      * @return a properly populated Activation object.
      */
     private Activation createActivation()
     {
         Activation activation = new Activation();
         activation.setActiveByDefault( false );
         activation.setOs( createOsBean() );
         return activation;
     }
 
     /**
      * Creates an ActivationOS object containing family, name, version and arch.
      *
      * @return a properly populated ActivationOS object.
      */
     private ActivationOS createOsBean()
     {
         ActivationOS os = new ActivationOS();
 
         os.setArch( arch );
         os.setFamily( family );
         os.setName( name );
         os.setVersion( version );
 
         return os;
     }
 
     /**
      * Helper method to check if the given family is in the following list:
      * <ul>
      * <li>dos</li>
      * <li>mac</li>
      * <li>netware</li>
      * <li>os/2</li>
      * <li>tandem</li>
      * <li>unix</li>
      * <li>windows</li>
      * <li>win9x</li>
      * <li>z/os</li>
      * <li>os/400</li>
      * </ul>
      * Note: '!' is allowed at the beginning of the string and still considered valid.
      *
      * @param theFamily the family to check.
      * @return true if one of the valid families.
      */
     public boolean isValidFamily( String theFamily )
     {
 
         // in case they are checking !family
         theFamily = StringUtils.stripStart( theFamily, "!" );
 
         return ( StringUtils.isEmpty( theFamily ) || Os.getValidFamilies().contains( theFamily ) );
     }
 
     /**
      * Gets the arch.
      *
      * @return the arch
      */
     public String getArch()
     {
         return this.arch;
     }
 
     /**
      * Sets the arch.
      *
      * @param theArch the arch to set
      */
     public void setArch( String theArch )
     {
         this.arch = theArch;
     }
 
     /**
      * Gets the family.
      *
      * @return the family
      */
     public String getFamily()
     {
         return this.family;
     }
 
     /**
      * Sets the family.
      *
      * @param theFamily the family to set
      */
     public void setFamily( String theFamily )
     {
         this.family = theFamily;
     }
 
     /**
      * Gets the name.
      *
      * @return the name
      */
     public String getName()
     {
         return this.name;
     }
 
     /**
      * Sets the name.
      *
      * @param theName the name to set
      */
     public void setName( String theName )
     {
         this.name = theName;
     }
 
     /**
      * Gets the version.
      *
      * @return the version
      */
     public String getVersion()
     {
         return this.version;
     }
 
     /**
      * Sets the version.
      *
      * @param theVersion the version to set
      */
     public void setVersion( String theVersion )
     {
         this.version = theVersion;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.maven.enforcer.rule.api.EnforcerRule#getCacheId()
      */
     public String getCacheId()
     {
         // return the hashcodes of all the parameters
         StringBuffer b = new StringBuffer();
         if ( StringUtils.isNotEmpty( version ) )
         {
             b.append( version.hashCode() );
         }
         if ( StringUtils.isNotEmpty( name ) )
         {
             b.append( name.hashCode() );
         }
         if ( StringUtils.isNotEmpty( arch ) )
         {
             b.append( arch.hashCode() );
         }
         if ( StringUtils.isNotEmpty( family ) )
         {
             b.append( family.hashCode() );
         }
         return b.toString();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.maven.enforcer.rule.api.EnforcerRule#isCacheable()
      */
     public boolean isCacheable()
     {
         // the os is not going to change between projects in the same build.
         return true;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.maven.enforcer.rule.api.EnforcerRule#isResultValid(org.apache.maven.enforcer.rule.api.EnforcerRule)
      */
     public boolean isResultValid( EnforcerRule theCachedRule )
     {
         // i will always return the hash of the parameters as my id. If my parameters are the same, this
         // rule must always have the same result.
         return true;
     }
 }