/*
    * Copyright 2010-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.testdoc.collect.extractor;
  
  import java.util.Map;
  
  import javax.lang.model.element.AnnotationMirror;
  import javax.lang.model.element.AnnotationValue;
  import javax.lang.model.element.Element;
  import javax.lang.model.element.ExecutableElement;
  
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.testdoc.annotations.Uut;
  
  /**
   * Extracts {@link Uut} annotation information.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  class TestDocAnnotationExtractor
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    /**
     * The unit under test (UUT) information from the annotation.
     */
    static final class UutInfo
    {
      /**
       * The type of the UUT.
       */
      private String type;
  
      /**
       * The method of the UUT.
       */
      private String method;
  
      /**
       * Returns the type of the UUT.
       *
       * @return the type of the UUT.
       */
      public String getType()
      {
        return type;
      }
  
      /**
       * Returns the method of the UUT.
       *
       * @return the method of the UUT.
       */
      public String getMethod()
      {
        return method;
      }
  
      /**
       * Checks if the UUT annotation provides a type property.
       *
       * @return <code>true</code> if a type property is provided,
       *         <code>false</code> if the type property is <code>null</code>.
       */
      public boolean hasType()
      {
        return type != null;
      }
  
      /**
       * Checks if the UUT annotation provides a non-blank method name.
       *
       * @return <code>true</code> if a non-blank method name is provided,
       *         <code>false</code> if the method name is blank.
      */
     public boolean hasMethod()
     {
       return StringUtils.isNotBlank(method);
     }
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Reads the UUT information from the annotation.
    *
    * @param testMethod the test method to check for {@link Uut} annotations.
    * @return the information of the annotation. The value is never
    *         <code>null</code>, but the info instance may provide no
    *         information.
    * @throws IllegalArgumentException if the extractor does not support all
    *           annotation properties provided.
    */
   UutInfo read(final Element testCaseType) throws IllegalArgumentException
   {
     final UutInfo info = new UutInfo();
     for (final AnnotationMirror annotation : testCaseType
         .getAnnotationMirrors())
     {
       if (isAnnotation(Uut.class, annotation))
       {
         return read(info, annotation);
       }
     }
 
     return info;
   }
 
   private boolean isAnnotation(final Class<?> type,
       final AnnotationMirror annotation)
   {
     return type.getName().equals(annotation.getAnnotationType().toString());
   }
 
   private static UutInfo read(final UutInfo info,
       final AnnotationMirror annotation) throws IllegalArgumentException
   {
     final Map<? extends ExecutableElement, ? extends AnnotationValue> map =
         annotation.getElementValues();
     for (final Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : map
         .entrySet())
     {
       addInfo(info, entry);
     }
     return info;
   }
 
   private static void addInfo(
       final UutInfo info,
       final Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry)
     throws IllegalArgumentException
   {
     final String key = entry.getKey().toString();
     if (isType(key))
     {
       final String value = entry.getValue().toString();
       final String typeName = typeNameFix(value);
       if (!Object.class.getName().equals(typeName))
       {
         info.type = typeName;
       }
     }
     else if (isMethod(key))
     {
       final Object value = entry.getValue().getValue();
       if (value instanceof String)
       {
         info.method = (String) value;
       }
     }
     else
     {
       throw new IllegalArgumentException(
           "Cannot support UUT annotation field '" + key + "'.");
     }
   }
 
   private static boolean isType(final String key)
   {
     return key != null && key.contains("type()");
   }
 
   private static boolean isMethod(final String key)
   {
     return key != null && key.contains("method()");
   }
 
   /**
    * Dependent on the implementation the value contains the <code>.class</code>
    * (Sun) suffix, or not (eclipse).
    */
   static String typeNameFix(final String typeNameString)
   {
     if (typeNameString.endsWith(".class"))
     {
       return typeNameString.substring(0, typeNameString.length() - 6);
     }
     else
     {
       return typeNameString;
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }