/*
    * Copyright 2007-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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 de.smartics.maven.exceptions.util;
  
  import org.apache.commons.lang.StringUtils;
  
  import com.sun.javadoc.ClassDoc;
  import com.sun.javadoc.Type;
  
  /**
   * Provides utilities for filtering on {@link com.sun.javadoc.Doc} elements.
   */
  public final class FilterUtils
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Utility class pattern.
     */
    private FilterUtils()
    {
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Checks if the given class is implementing the given interface type. It runs
     * up the inheritance path to the root to see if any parent class implements
     * the specified interface.
     *
     * @param classDoc the class that is tested on implementing the interface of
     *          the given type.
     * @param type the type of the interface to test.
     * @return <code>true</code> if the class implements the given type,
     *         <code>false</code> otherwise.
     */
    public static boolean isImplementing(
        final ClassDoc classDoc,
        final Class<?> type)
    {
      if (classDoc == null)
      {
        return false;
      }
  
      final boolean declared = isInterfaceDeclared(classDoc, type);
      if (!declared)
      {
        final ClassDoc parentClassDoc = classDoc.superclass();
        return isImplementing(parentClassDoc, type);
      }
      else
      {
        return true;
      }
    }
  
    /**
     * Checks if the given class is implementing the given interface type
     * directly.
     * <p>
     * If the <code>classDoc</code> value is <code>null</code>, <code>false</code>
     * is returned. This is to provide the same interface as in
     * {@link #isImplementing(ClassDoc, Class)}.
     * </p>
     *
     * @param classDoc the class that is tested on implementing the interface of
     *          the given type.
     * @param type the type of the interface to test.
     * @return <code>true</code> if the class declares the given type in its
    *         implements clause, <code>false</code> otherwise.
    * @throws NullPointerException if the given interface <code>type</code> is
    *           <code>null</code>.
    */
   public static boolean isInterfaceDeclared(
       final ClassDoc classDoc,
       final Class<?> type) throws NullPointerException
   {
     if (classDoc == null)
     {
       return false;
     }
 
     final String typeName = type.getName();
     final Type[] implementedTypes = classDoc.interfaceTypes();
     for (Type implementedType : implementedTypes)
     {
       final String name = implementedType.qualifiedTypeName();
       if (typeName.equals(name))
       {
         return true;
       }
       else
       {
         final boolean extending =
             isInterfaceDeclaredInExtendingInterfaces(implementedType, typeName);
         if (extending)
         {
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * Checks if the the <code>typeName</code> matches with any type the given
    * <code>implementedType</code> extends. The <code>implementedType</code>
    * itself is not checked.
    *
    * @param implementedType type whose extended interfaces (the
    *          <code>implementedType</code> extends these interfaces) are
    *          checked.
    * @param typeName the name of the type that has to be matched.
    * @return <code>true</code> if the <code>typeName</code> matches any type
    *         that is extended by <code>implementedType</code> (depth first
    *         search), <code>false</code> otherwise.
    */
   private static boolean isInterfaceDeclaredInExtendingInterfaces(
       final Type implementedType,
       final String typeName)
   {
     final ClassDoc interfaceDoc = implementedType.asClassDoc();
     final Type[] extendingInterfaces = interfaceDoc.interfaceTypes();
     for (Type extendingInterface : extendingInterfaces)
     {
       final String name = extendingInterface.qualifiedTypeName();
       if (typeName.equals(name))
       {
         return true;
       }
       else
       {
         final boolean extending =
             isInterfaceDeclaredInExtendingInterfaces(extendingInterface,
                 typeName);
         if (extending)
         {
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * Checks if the given token is a valid Java identifier.
    *
    * @param token the token to check.
    * @return <code>true</code> if the token is a valid Java identifier,
    *         <code>false</code> otherwise.
    */
   public static boolean isValidJavaIdentifier(final String token)
   {
     if (StringUtils.isBlank(token)
         || !Character.isJavaIdentifierStart(token.charAt(0)))
     {
       return false;
     }
 
     for (int i = token.length() - 1; i >= 1; i--)
     {
       final char c = token.charAt(i);
       if (!Character.isJavaIdentifierPart(c))
       {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Checks that the path is a valid directory path for packages.
    *
    * @param path the path to check if it is valid.
    * @return <code>true</code> if every directory name in the path is a valid
    *         Java package name, <code>false</code> otherwise.
    */
   public static boolean isValidJavaPackageDirPath(final String path)
   {
     if (StringUtils.isBlank(path))
     {
       return false;
     }
 
     final String normalized = path.replace('\\', '/');
     final String[] parts = normalized.split("/");
     if (parts.length == 0)
     {
       return false;
     }
     for (String part : parts)
     {
       if (!FilterUtils.isValidJavaIdentifier(part))
       {
         return false;
       }
     }
     return true;
   }
 
   // --- object basics --------------------------------------------------------
 
 }