/*
    * 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.lang.annotation.Annotation;
  import java.util.List;
  
  import javax.lang.model.element.Element;
  import javax.lang.model.element.ElementKind;
  import javax.lang.model.element.ExecutableElement;
  import javax.lang.model.element.TypeElement;
  import javax.lang.model.util.Elements;
  
  import org.junit.Test;
  import org.junit.experimental.theories.Theory;
  
  import de.smartics.testdoc.annotations.Uut;
  import de.smartics.testdoc.collect.extractor.TestDocHintsExtractor.Hints;
  import de.smartics.testdoc.collect.extractor.TestDocAnnotationExtractor.UutInfo;
  import de.smartics.testdoc.core.doc.ScenarioTestDoc;
  import de.smartics.testdoc.core.doc.SortKey;
  import de.smartics.testdoc.core.doc.TestMethodDoc;
  import de.smartics.testdoc.core.doc.Type;
  import de.smartics.testdoc.core.doc.UnitTestDoc;
  import de.smartics.testdoc.core.doc.names.TestNameUtils;
  import de.smartics.testdoc.core.source.SourceCodeHelper;
  import de.smartics.util.source.SourceCodeLocation;
  
  /**
   * Base implementation for Extracting unit test doc information.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public abstract class AbstractExtractor
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The utilities of the APT interface.
     */
    protected final Elements elementUtils;
  
    /**
     * The helper to access source code information.
     */
    protected final SourceCodeHelper sourceCodeHelper;
  
    /**
     * The utilities to create names to be displayed (as labels) for tests.
     */
    private final TestNameUtils testNameUtils;
  
    /**
     * The test case that is analyzed.
     */
    protected final TypeElement testCaseType;
  
    /**
     * Extracts category information.
     */
    protected final CategoryExtractor categoryExtractor;
  
    /**
     * Extracts hint information.
     */
    protected final TestDocHintsExtractor hintExtractor =
        new TestDocHintsExtractor();
  
    /**
     * Extracts UUT information.
     */
    protected final TestDocAnnotationExtractor uutExtractor =
        new TestDocAnnotationExtractor();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
    * @param config the configuration to access processing information.
    * @param testCaseType the test case that has an annotation that potentially
    *          specifies the unit under test.
    * @throws IllegalArgumentException if the <code>declaredUutField</code> is
    *           not a field declaration within a class or any of the arguments is
    *           <code>null</code>.
    */
   protected AbstractExtractor(final ExtractorConfig config,
       final TypeElement testCaseType) throws IllegalArgumentException
   {
     checkArguments(config);
     this.elementUtils = config.getElementUtils();
     this.sourceCodeHelper = config.getSourceCodeHelper();
     this.testNameUtils = config.getTestNameUtils();
     this.testCaseType = testCaseType;
     this.categoryExtractor = new CategoryExtractor(testCaseType);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private void checkArguments(final ExtractorConfig config)
   {
     if (config == null)
     {
       throw new IllegalArgumentException("The extractor config is required.");
     }
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Reads the test documentation from the element the extractor instance is
    * associated with.
    *
    * @return the test documentation read.
    */
   public abstract UnitTestDoc readTestDoc();
 
   protected ScenarioTestDoc createScenarioIfElementIsTestMethod(
       final UutInfo uutInfo, final String testCaseType,
       final ExecutableElement testMethod)
   {
     final String uutMethod = uutInfo.getMethod();
     final Hints methodHints = hintExtractor.readHints(testMethod);
     final TestMethodDoc testMethodDoc =
         createTestMethod(methodHints, testMethod);
     final List<String> categories =
         categoryExtractor.calcCategories(testMethod);
 
     final Hints typeHints =
         hintExtractor.readHints(testMethod.getEnclosingElement());
     final SortKey sortKey = methodHints.createSortKey(typeHints);
     final ScenarioTestDoc scenario =
         new ScenarioTestDoc(uutMethod, new Type(testCaseType), testMethodDoc,
             categories, sortKey);
     return scenario;
   }
 
   private TestMethodDoc createTestMethod(final Hints methodHints,
       final ExecutableElement testMethod)
   {
     final String testName = testMethod.getSimpleName().toString();
     final String testSentence = calculateTestSentence(methodHints, testName);
     final SourceCodeLocation location =
         sourceCodeHelper.getSourceCodeLocation(testMethod);
     final String comment = elementUtils.getDocComment(testMethod);
     return new TestMethodDoc(testName, testSentence, location, comment);
   }
 
   protected String calculateTestSentence(final Hints hints,
       final String testName)
   {
     if (hints.hasSentence())
     {
       return hints.getSentence();
     }
     else
     {
       return testNameUtils.calculateTestNameSentence(testName);
     }
   }
 
   protected static boolean isTestMethodWithoutUutAnnotation(
       final Element element)
   {
     final ElementKind kind = element.getKind();
     if (ElementKind.METHOD.equals(kind))
     {
       final ExecutableElement method = (ExecutableElement) element;
       return (hasNotAnnotation(method, Uut.class) && (hasAnnotation(method,
           Test.class) || hasAnnotation(method, Theory.class)));
     }
     return false;
   }
 
   protected static boolean hasAnnotation(final Element method,
       final Class<? extends Annotation> annotation)
   {
     return null != method.getAnnotation(annotation);
   }
 
   protected static boolean hasNotAnnotation(final Element method,
       final Class<? extends Annotation> annotation)
   {
     return null == method.getAnnotation(annotation);
   }
 
   // --- object basics --------------------------------------------------------
 
 }