/*
    * 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.report.export.doc;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.NullArgumentException;
  
  import de.smartics.maven.util.report.link.ExternalReport;
  import de.smartics.maven.util.report.link.ExternalReportFactory;
  import de.smartics.maven.util.report.link.LinkConstructorStrategy;
  import de.smartics.maven.util.report.link.ReportId;
  
  /**
   * Manages report instances and their grouping.
   */
  public class ExternalReportReferences
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * An empty report reference instance that prohibits adding information.
     */
    public static final ExternalReportReferences EMPTY =
        new ExternalReportReferences(null)
        {
          public boolean registerReport(final boolean create,
              final ReportId reportId, final LinkConstructorStrategy strategy)
          {
            throw new UnsupportedOperationException(
                "It is not allowed to add to the empty report references.");
          }
  
          public void addUutReportId(final ReportId reportId)
          {
            throw new UnsupportedOperationException(
                "It is not allowed to add report IDs.");
          }
  
          public void addTestCaseReportId(final ReportId reportId)
          {
            throw new UnsupportedOperationException(
                "It is not allowed to add report IDs.");
          }
        };
  
    // --- members --------------------------------------------------------------
  
    /**
     * The factory to create new reports.
     */
    private final ExternalReportFactory factory;
  
    /**
     * The map of all registered reports.
     */
    private final Map<ReportId, ExternalReport> reports =
        new HashMap<ReportId, ExternalReport>();
  
    /**
     * The ordered list of report IDs to render for the UUT.
     */
    private final List<ReportId> uutReportIds = new ArrayList<ReportId>();
  
    /**
     * The ordered list of report IDs to render for the test case.
     */
    private final List<ReportId> testCaseReportIds = new ArrayList<ReportId>();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     */
    public ExternalReportReferences(final ExternalReportFactory factory)
    {
      this.factory = factory;
    }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the list of report IDs that are to referenced from a UUT.
    *
    * @return the list of report IDs
    */
   public List<ReportId> getUutReportIds()
   {
     return Collections.unmodifiableList(uutReportIds);
   }
 
   /**
    * Returns the list of report IDs that are to referenced from a test case.
    *
    * @return the list of report IDs
    */
   public List<ReportId> getTestCaseReportIds()
   {
     return Collections.unmodifiableList(testCaseReportIds);
   }
 
   /**
    * Returns the ordered list of report IDs to render for the UUT.
    *
    * @return the ordered list of report IDs to render for the UUT.
    */
   public List<ExternalReport> getUutReports()
   {
     return getReports(getUutReportIds());
   }
 
   /**
    * Returns the ordered list of report IDs to render for the test case.
    *
    * @return the ordered list of report IDs to render for the test case.
    */
   public List<ExternalReport> getTestCaseReports()
   {
     return getReports(getTestCaseReportIds());
   }
 
   // --- business -------------------------------------------------------------
 
   /**
    * Adds the report ID to the list of IDs to render UUT report references.
    *
    * @param reportId the report ID to add.
    * @throws NullArgumentException if {@code reportId} is <code>null</code>.
    */
   public void addUutReportId(final ReportId reportId)
     throws NullArgumentException
   {
     if (reportId == null)
     {
       throw new NullArgumentException("reportId"); // NOPMD
     }
 
     uutReportIds.add(reportId);
   }
 
   /**
    * Adds the report ID to the list of IDs to render test case report
    * references.
    *
    * @param reportId the report ID to add.
    * @throws NullArgumentException if {@code reportId} is <code>null</code>.
    */
   public void addTestCaseReportId(final ReportId reportId)
     throws NullArgumentException
   {
     if (reportId == null)
     {
       throw new NullArgumentException("reportId"); // NOPMD
     }
     testCaseReportIds.add(reportId);
   }
 
   /**
    * Registers a report with the given identifier and strategy.
    * <p>
    * Note that no report will be registered, if the factory of this instance is
    * not set.
    * </p>
    *
    * @param reportId the identifier of the report to register.
    * @param strategy the link constructor strategy to use.
    * @return <code>true</code> if the report has been created and registered,
    *         <code>false</code> otherwise.
    */
   public boolean registerReport(final ReportId reportId,
       final LinkConstructorStrategy strategy)
   {
     return registerReport(true, reportId, strategy);
   }
 
   /**
    * Registers a report with the given identifier and strategy with a guard. The
    * guard allows to conveniently call this method without the burden of
    * specifying an if block on the caller's side.
    * <p>
    * Note that no report will be registered, if the factory of this instance is
    * not set.
    * </p>
    *
    * @param create convenience flag to not register the instance.
    * @param reportId the identifier of the report to register.
    * @param strategy the link constructor strategy to use.
    * @return <code>true</code> if the report has been created and registered,
    *         <code>false</code> otherwise.
    */
   public boolean registerReport(final boolean create, final ReportId reportId,
       final LinkConstructorStrategy strategy)
   {
     if (create && factory != null)
     {
       if (reportId == null)
       {
         throw new NullArgumentException("reportId"); // NOPMD
       }
 
       final ExternalReport report =
           factory.createExternalReport(reportId, strategy);
       final boolean created = report != null;
       if (created)
       {
         reports.put(reportId, report);
       }
       return created;
     }
 
     return false;
   }
 
   /**
    * Returns the report with the given ID.
    *
    * @param reportId the ID of the requested report.
    * @return the requested report instance or <code>null</code> if the ID does
    *         not reference to such an instance.
    */
   public ExternalReport get(final ReportId reportId)
   {
     return reports.get(reportId);
   }
 
   /**
    * Returns the list of reports with the given IDs.
    *
    * @param reportIds the IDs of the requested reports.
    * @return the list of reports, which may be empty, but is never
    *         <code>null</code>.
    */
   public List<ExternalReport> getReports(final List<ReportId> reportIds)
   {
     final List<ExternalReport> reports =
         new ArrayList<ExternalReport>(reportIds.size());
 
     for (final ReportId reportId : reportIds)
     {
       reports.add(get(reportId));
     }
 
     return reports;
   }
 
   // --- object basics --------------------------------------------------------
 
 }