/*
    * 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.core.doc;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.NullArgumentException;
  
  import net.jcip.annotations.GuardedBy;
  import net.jcip.annotations.ThreadSafe;
  
  /**
   * The index of all collected unit test documentation instances.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  @ThreadSafe
  public class UnitTestDocIndex implements Serializable
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    /**
     * The guard name for synchronization.
     */
    private static final String GUARD = "unitTestDocs";
  
    // --- members --------------------------------------------------------------
  
    /**
     * The test documentation mapped by the UUT's type name. For each type there
     * is only one instance of {@link UnitTestDoc} that contains all information
     * for that UUT.
     */
    private final Map<Type, UnitTestDoc> unitTestDocs =
        new LinkedHashMap<Type, UnitTestDoc>();
  
    /**
     * References from the test case classes to the units they test. The elements
     * in the list are required to be the identical instances found in
     * {@link #unitTestDocs}. This is just an alternative view on the UUTs to that
     * of {@link #unitTestDocs}.
     */
    private final Map<Type, List<UnitTestDoc>> testCases =
        new LinkedHashMap<Type, List<UnitTestDoc>>();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     */
    public UnitTestDocIndex()
    {
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    /**
     * Returns a copy of the internal map that contains the test documentation
     * instances.
     *
     * @return the content of the index.
     */
    @GuardedBy(GUARD)
    public List<UnitTestDoc> getUnitTestDocs()
    {
     synchronized (unitTestDocs)
     {
       return new ArrayList<UnitTestDoc>(unitTestDocs.values());
     }
   }
 
   /**
    * Returns the number of registered unit test documentation.
    *
    * @return the number of registered unit test documentation.
    */
   @GuardedBy(GUARD)
   public Integer getSize()
   {
     synchronized (unitTestDocs)
     {
       return unitTestDocs.size();
     }
   }
 
   /**
    * Checks whether the index contains elements or not.
    *
    * @return <code>true</code> if there is at least on element in the index,
    *         <code>false</code> otherwise.
    */
   @GuardedBy(GUARD)
   public boolean isEmpty()
   {
     synchronized (unitTestDocs)
     {
       return unitTestDocs.isEmpty();
     }
   }
 
   // --- business -------------------------------------------------------------
 
   /**
    * Registers the given test documentation to the index. If a documentation is
    * already registered, all information from the given <code>testDoc</code> is
    * added to the already registered instance.
    *
    * @param unitTestDoc the test documentation to add.
    * @return a reference to the registered instance.
    * @throws NullPointerException if <code>testDoc</code> is <code>null</code>.
    */
   @GuardedBy(GUARD)
   public UnitTestDoc register(final UnitTestDoc unitTestDoc)
     throws NullPointerException
   {
     final Type uutType = unitTestDoc.getUutType();
     synchronized (unitTestDocs)
     {
       final UnitTestDoc representative;
       if (unitTestDocs.containsKey(uutType))
       {
         representative = unitTestDocs.get(uutType);
         representative.addScenarios(unitTestDoc);
       }
       else
       {
         representative = unitTestDoc;
         unitTestDocs.put(uutType, representative);
       }
       registerByTestCase(representative);
       return representative;
     }
   }
 
   /**
    * Requires to be run synchronized with {@link #GUARD}. It also expects that
    * the <code>testDoc</code> is the instance that is registered with
    * {@link #unitTestDocs}.
    */
   private void registerByTestCase(final UnitTestDoc testDoc)
   {
     scenarios: for (final ScenarioTestDoc scenario : testDoc.getScenarios())
     {
       final Type testCaseType = scenario.getTestCaseType();
       List<UnitTestDoc> unitTestDocs = this.testCases.get(testCaseType);
       if (unitTestDocs == null)
       {
         unitTestDocs = new ArrayList<UnitTestDoc>();
         testCases.put(testCaseType, unitTestDocs);
       }
       else
       {
         for (final UnitTestDoc currentTestDoc : unitTestDocs)
         {
           if (testDoc == currentTestDoc)
           {
             continue scenarios; // type already registered.
           }
         }
       }
       unitTestDocs.add(testDoc);
     }
   }
 
   /**
    * Returns the unit test documentation for the given UUT type.
    *
    * @param uutType the type of the UUT whose test documentation is requested.
    * @return the test documentation for the given UUT type or <code>null</code>
    *         if nothing is registered for that type.
    */
   @GuardedBy(GUARD)
   public UnitTestDoc get(final Type uutType)
   {
     synchronized (unitTestDocs)
     {
       return unitTestDocs.get(uutType);
     }
   }
 
   /**
    * Returns the list of UUT documentation whose UUT is tested by the given test
    * case.
    *
    * @param testCaseType the type of the test case whose UUT documentation is
    *          requested.
    * @return the UUT documentation of all UUTs tested by the given test case
    *         type.
    */
   @GuardedBy(GUARD)
   public List<UnitTestDoc> getByTestCase(final Type testCaseType)
   {
     synchronized (unitTestDocs)
     {
       final List<UnitTestDoc> registered = testCases.get(testCaseType);
       if (registered != null)
       {
         final List<UnitTestDoc> unitTestsOfTestCase =
             filterScenariosByTestCase(testCaseType, registered);
 
         return Collections.unmodifiableList(unitTestsOfTestCase);
       }
       else
       {
         return Collections.emptyList();
       }
     }
   }
 
   private static List<UnitTestDoc> filterScenariosByTestCase(
       final Type testCaseType, final List<UnitTestDoc> registered)
   {
     final List<UnitTestDoc> unitTestsOfTestCase =
         new ArrayList<UnitTestDoc>(registered.size());
     for (final UnitTestDoc unitTestDoc : registered)
     {
       final List<ScenarioTestDoc> scenariosOfTestCase =
           filterScenarios(testCaseType, unitTestDoc);
       final UnitTestDoc unitTestDocOfTestCase =
           cloneWithNewScenarios(unitTestDoc, scenariosOfTestCase);
       unitTestsOfTestCase.add(unitTestDocOfTestCase);
     }
     return unitTestsOfTestCase;
   }
 
   private static List<ScenarioTestDoc> filterScenarios(final Type testCaseType,
       final UnitTestDoc unitTestDoc)
   {
     final List<ScenarioTestDoc> scenariosOfTestCase =
         new ArrayList<ScenarioTestDoc>();
     for (final ScenarioTestDoc scenario : unitTestDoc.getScenarios())
     {
       if (testCaseType.equals(scenario.getTestCaseType()))
       {
         scenariosOfTestCase.add(scenario);
       }
     }
     return scenariosOfTestCase;
   }
 
   private static UnitTestDoc cloneWithNewScenarios(
       final UnitTestDoc unitTestDoc,
       final List<ScenarioTestDoc> scenariosOfTestCase)
   {
     final UnitTestDoc unitTestDocOfTestCase =
         new UnitTestDoc(unitTestDoc.getUutType(), scenariosOfTestCase);
     return unitTestDocOfTestCase;
   }
 
   /**
    * Removes all scenarios of the given test case type.
    *
    * @param testCaseType the type of the test case whose scenario are to be
    *          removed.
    * @throws NullArgumentException if <code>testCaseType</code> is
    *           <code>null</code>.
    */
   @GuardedBy(GUARD)
   public void deregisterTestCase(final Type testCaseType)
     throws NullArgumentException
   {
     if (testCaseType == null)
     {
       throw new NullArgumentException("testCaseType");
     }
 
     synchronized (unitTestDocs)
     {
       final List<UnitTestDoc> unitTestDocsOfTestCase =
           testCases.get(testCaseType);
       if (unitTestDocsOfTestCase != null)
       {
         for (final UnitTestDoc unitTestDoc : unitTestDocsOfTestCase)
         {
           unitTestDoc.removeScenarios(testCaseType);
         }
       }
     }
   }
 
   /**
    * Clears the index.
    */
   @GuardedBy(GUARD)
   public void clear()
   {
     synchronized (unitTestDocs)
     {
       unitTestDocs.clear();
       testCases.clear();
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }