/*
    * 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 java.util.Map.Entry;
  
  import javax.lang.model.element.AnnotationMirror;
  import javax.lang.model.element.AnnotationValue;
  import javax.lang.model.element.Element;
  
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.testdoc.annotations.TestDocHint;
  import de.smartics.testdoc.core.doc.SortKey;
  
  /**
   * Extracts {@link TestDocHint} information.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  class TestDocHintsExtractor
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    /**
     * The hint information from the annotation.
     */
    static final class Hints
    {
      /**
       * The sentence provided by the hint.
       */
      private String sentence;
  
      /**
       * The main index key.
       */
      public String mainSortKey;
  
      /**
       * The index key.
       */
      public String indexSortKey;
  
      Hints()
      {
      }
  
      /**
       * Returns the sentence provided by the hint.
       *
       * @return the sentence provided by the hint.
       */
      public String getSentence()
      {
        return sentence;
      }
  
      // /**
      // * Returns the sentence provided by the hint.
      // *
      // * @param defaultValue the default value if the hint provides no sentence.
      // * @return the sentence provided by the hint.
      // */
      // public String getSentence(final String defaultValue)
      // {
      // return hasSentence() ? sentence : defaultValue;
      // }
  
      /**
       * Checks if the hint provides a non-blank sentence.
       *
       * @return <code>true</code> if a non-blank sentence is provided,
       *         <code>false</code> if the sentence is blank.
      */
     public boolean hasSentence()
     {
       return StringUtils.isNotBlank(sentence);
     }
 
     /**
      * Returns the main index key.
      *
      * @return the main index key.
      */
     public String getMainSortKey()
     {
       return mainSortKey;
     }
 
     /**
      * Returns the index key.
      *
      * @return the index key.
      */
     public String getIndexSortKey()
     {
       return indexSortKey;
     }
 
     /**
      * Creates a sort key upon the key information in this hints instance with
      * the given hints as defaults.
      *
      * @param defaultHints the defaults if this instance provides no
      *          information.
      * @return the generated sort key.
      */
     public SortKey createSortKey(final Hints defaultHints)
     {
       final String mainIndexKey =
           calcIndexKey(getMainSortKey(),
               (defaultHints != null) ? defaultHints.getMainSortKey() : null);
       final String indexKey =
           calcIndexKey(getIndexSortKey(),
               (defaultHints != null) ? defaultHints.getIndexSortKey() : null);
       final SortKey sortKey = new SortKey(mainIndexKey, indexKey);
       return sortKey;
     }
 
     private static String calcIndexKey(final String key, final String defaultKey)
     {
       if (key == null)
       {
         return defaultKey;
       }
       return key;
     }
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Reads the hints from the annotation.
    *
    * @param element the element to check for {@link TestDocHint} annotations.
    * @return the hints of the annotation. The value is never <code>null</code>,
    *         but the hint instance may provide no information.
    */
   Hints readHints(final Element element)
   {
     final Hints hints = new Hints();
     for (final AnnotationMirror annotation : element.getAnnotationMirrors())
     {
       if (TestDocHint.class.getName().equals(
           annotation.getAnnotationType().toString()))
       {
         return readHints(hints, annotation);
       }
     }
 
     return hints;
   }
 
   private static Hints readHints(final Hints hints,
       final AnnotationMirror annotation)
   {
     final Map<? extends Element, ? extends AnnotationValue> map =
         annotation.getElementValues();
     for (final Map.Entry<? extends Element, ? extends AnnotationValue> entry : map
         .entrySet())
     {
       addHint(hints, entry);
     }
     return hints;
   }
 
   private static void addHint(final Hints hints,
       final Map.Entry<? extends Element, ? extends AnnotationValue> entry)
   {
     final String key = entry.getKey().toString();
     if (isKey(key, "sentence()"))
     {
       final Object value = entry.getValue().getValue();
       if (value instanceof String)
       {
         hints.sentence = (String) value;
       }
     }
     if (isKey(key, "mainSortKey()"))
     {
       hints.mainSortKey = calcStringValue(entry);
     }
     if (isKey(key, "indexSortKey()"))
     {
       hints.indexSortKey = calcStringValue(entry);
     }
   }
 
   private static boolean isKey(final String key, final String suffix)
   {
     return key != null && key.trim().endsWith(suffix);
   }
 
   private static String calcStringValue(
       final Entry<? extends Element, ? extends AnnotationValue> entry)
   {
     final Object value = entry.getValue().getValue();
 
     if (value instanceof String)
     {
       final String stringValue = (String) value;
       if (StringUtils.isNotBlank(stringValue))
       {
         return stringValue;
       }
     }
     return null;
   }
 
   // --- object basics --------------------------------------------------------
 
 }