/*
    * 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.
   */
  package org.apache.commons.cli2.validation;
  
  import java.util.List;
  import java.util.ListIterator;
  
  import org.apache.commons.cli2.resource.ResourceConstants;
  import org.apache.commons.cli2.resource.ResourceHelper;
  
  /**
   * The <code>ClassValidator</code> validates the string argument
   * values are class names.
   *
   * The following example shows how to validate the 'logger'
   * argument value is a class name, that can be instantiated.
   *
   * <pre>
   * ...
   * ClassValidator validator = new ClassValidator();
   * validator.setInstance(true);
   *
   * ArgumentBuilder builder = new ArgumentBuilder();
   * Argument logger =
   *     builder.withName("logger");
   *            .withValidator(validator);
   * </pre>
   *
   * @author John Keyes
   */
  public class ClassValidator implements Validator {
      /** i18n */
      private static final ResourceHelper resources = ResourceHelper.getResourceHelper();
  
      /** whether the class argument is loadable */
      private boolean loadable;
  
      /** whether to create an instance of the class */
      private boolean instance;
  
      /** the classloader to load classes from */
      private ClassLoader loader;
  
      /**
       * Validate each argument value in the specified List against this instances
       * permitted attributes.
       *
       * If a value is valid then it's <code>String</code> value in the list is
       * replaced with it's <code>Class</code> value or instance.
       *
       * @see org.apache.commons.cli2.validation.Validator#validate(java.util.List)
       */
      public void validate(final List values)
          throws InvalidArgumentException {
          for (final ListIterator i = values.listIterator(); i.hasNext();) {
              final String name = (String) i.next();
  
              if (!isPotentialClassName(name)) {
                  throw new InvalidArgumentException(resources.getMessage(ResourceConstants.CLASSVALIDATOR_BAD_CLASSNAME,
                                                                          name));
              }
  
              if (loadable || instance) {
                  final ClassLoader theLoader = getClassLoader();
  
                  try {
                      final Class clazz = theLoader.loadClass(name);
  
                      if (instance) {
                          i.set(clazz.newInstance());
                      } else {
                          i.set(clazz);
                      }
                  } catch (final ClassNotFoundException exp) {
                      throw new InvalidArgumentException(resources.getMessage(ResourceConstants.CLASSVALIDATOR_CLASS_NOTFOUND,
                                                                              name));
                  } catch (final IllegalAccessException exp) {
                      throw new InvalidArgumentException(resources.getMessage(ResourceConstants.CLASSVALIDATOR_CLASS_ACCESS,
                                                                              name, exp.getMessage()));
                  } catch (final InstantiationException exp) {
                      throw new InvalidArgumentException(resources.getMessage(ResourceConstants.CLASSVALIDATOR_CLASS_CREATE,
                                                                              name));
                  }
              }
          }
     }
 
     /**
      * Returns whether the argument value must represent a
      * class that is loadable.
      *
      * @return whether the argument value must represent a
      * class that is loadable.
      */
     public boolean isLoadable() {
         return loadable;
     }
 
     /**
      * Specifies whether the argument value must represent a
      * class that is loadable.
      *
      * @param loadable whether the argument value must
      * represent a class that is loadable.
      */
     public void setLoadable(boolean loadable) {
         this.loadable = loadable;
     }
 
     /**
      * Returns the {@link ClassLoader} used to resolve and load
      * the classes specified by the argument values.
      *
      * @return the {@link ClassLoader} used to resolve and load
      * the classes specified by the argument values.
      */
     public ClassLoader getClassLoader() {
         if (loader == null) {
             loader = getClass().getClassLoader();
         }
 
         return loader;
     }
 
     /**
      * Specifies the {@link ClassLoader} used to resolve and load
      * the classes specified by the argument values.
      *
      * @param loader the {@link ClassLoader} used to resolve and load
      * the classes specified by the argument values.
      */
     public void setClassLoader(ClassLoader loader) {
         this.loader = loader;
     }
 
     /**
      * Returns whether the argument value must represent a
      * class that can be instantiated.
      *
      * @return whether the argument value must represent a
      * class that can be instantiated.
      */
     public boolean isInstance() {
         return instance;
     }
 
     /**
      * Specifies whether the argument value must represent a
      * class that can be instantiated.
      *
      * @param instance whether the argument value must
      * represent a class that can be instantiated.
      */
     public void setInstance(boolean instance) {
         this.instance = instance;
     }
 
     /**
      * Returns whether the specified name is allowed as
      * a Java class name.
      * @param name the name to be checked
      * @return true if allowed as Java class name
      */
     protected boolean isPotentialClassName(final String name) {
         final char[] chars = name.toCharArray();
 
         boolean expectingStart = true;
 
         for (int i = 0; i < chars.length; ++i) {
             final char c = chars[i];
 
             if (expectingStart) {
                 if (!Character.isJavaIdentifierStart(c)) {
                     return false;
                 }
 
                 expectingStart = false;
             } else {
                 if (c == '.') {
                     expectingStart = true;
                 } else if (!Character.isJavaIdentifierPart(c)) {
                     return false;
                 }
             }
         }
 
         return !expectingStart;
     }
 }