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.io.File;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.maven.enforcer.rule.api.EnforcerRule;
  import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
  import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
  
  /**
   * Contains the common code to compare an array of files against a requirement.
   *
   * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
   */
  public abstract class AbstractRequireFiles
      extends AbstractStandardEnforcerRule
  {
  
      /** Array of files to check. */
      File[] files;
  
      /** if null file handles should be allowed. If they are allowed, it means treat it as a success. */
      boolean allowNulls = false;
  
      // check the file for the specific condition
      /**
       * Check one file.
       *
       * @param file the file
       * @return <code>true</code> if successful
       */
      abstract boolean checkFile( File file );
  
      // return standard error message
      /**
       * Gets the error msg.
       *
       * @return the error msg
       */
      abstract String getErrorMsg();
  
      /*
       * (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
      {
  
          if ( !allowNulls && files.length == 0 )
      	{
              throw new EnforcerRuleException( "The file list is empty and Null files are disabled." );
      	}
  
          List<File> failures = new ArrayList<File>();
          for ( File file : files )
          {
              if ( !allowNulls && file == null )
          	{
                  failures.add( file );
          	}
          	else if ( !checkFile( file ) )
              {
                  failures.add( file );
              }
          }
  
          // if anything was found, log it with the optional message.
          if ( !failures.isEmpty() )
          {
              StringBuilder buf = new StringBuilder();
              if ( message != null )
              {
                  buf.append( message + "\n" );
              }
              buf.append( getErrorMsg() );
  
              for ( File file : failures )
             {
                 if ( file != null )
                 {
                     buf.append( file.getAbsolutePath() + "\n" );
                 }
                 else
                 {
                     buf.append( "(an empty filename was given and allowNulls is false)\n" );
                 }
             }
 
             throw new EnforcerRuleException( buf.toString() );
         }
     }
 
     /**
      * If your rule is cacheable, you must return a unique id when parameters or conditions change that would cause the
      * result to be different. Multiple cached results are stored based on their id. The easiest way to do this is to
      * return a hash computed from the values of your parameters. If your rule is not cacheable, then the result here is
      * not important, you may return anything.
      *
      * @return the cache id
      */
     public String getCacheId()
     {
         return Integer.toString( hashCode( files ) );
     }
 
     /**
      * Calculates a hash code for the specified array as <code>Arrays.hashCode()</code> would do. Unfortunately, the
      * mentioned method is only available for Java 1.5 and later.
      *
      * @param items The array for which to compute the hash code, may be <code>null</code>.
      * @return The hash code for the array.
      */
     private static int hashCode( Object[] items )
     {
         int hash = 0;
         if ( items != null )
         {
             hash = 1;
             for ( int i = 0; i < items.length; i++ )
             {
                 Object item = items[i];
                 hash = 31 * hash + ( item == null ? 0 : item.hashCode() );
             }
         }
         return hash;
     }
 
     /**
      * This tells the system if the results are cacheable at all. Keep in mind that during forked builds and other
      * things, a given rule may be executed more than once for the same project. This means that even things that change
      * from project to project may still be cacheable in certain instances.
      *
      * @return <code>true</code> if rule is cacheable
      */
     public boolean isCacheable()
     {
         return true;
     }
 
     /**
      * If the rule is cacheable and the same id is found in the cache, the stored results are passed to this method to
      * allow double checking of the results. Most of the time this can be done by generating unique ids, but sometimes
      * the results of objects returned by the helper need to be queried. You may for example, store certain objects in
      * your rule and then query them later.
      *
      * @param cachedRule the cached rule
      * @return <code>true</code> if the stored results are valid for the same id.
      */
     public boolean isResultValid( EnforcerRule cachedRule )
     {
         return true;
     }
 }