/*
    * Copyright 2008-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.maven.issues.bugzilla;
  
  import java.util.Comparator;
  import java.util.List;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.maven.artifact.versioning.ArtifactVersion;
  import org.eclipse.mylyn.internal.bugzilla.core.BugzillaAttribute;
  import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
  import org.eclipse.mylyn.tasks.core.data.TaskData;
  
  import de.smartics.maven.issues.RendererConfig;
  
  /**
   * Selects the issues to their categories.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public class VersionedSectioner implements Sectioner<Versions>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private static final Log LOG = LogFactory.getLog(VersionedSectioner.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The configuration to control the processing of the sections.
     */
    private final RendererConfig config;
  
    /**
     * The issues to be appointed to the different sections.
     */
    private final List<TaskData> issues;
  
    /**
     * The map stores the bugs in the order read from the issue management system
     * in different sections within different target versions.
     */
    private final Versions versions;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor using inverse sort order for versions.
     *
     * @param config the configuration to control the processing of the sections.
     * @param issues the issues to be appointed to the different sections.
     */
    public VersionedSectioner(final RendererConfig config,
        final List<TaskData> issues)
    {
      this.config = config;
      this.issues = issues;
      this.versions = new Versions(config.getSections());
    }
  
    /**
     * Default constructor.
     *
     * @param config the configuration to control the processing of the sections.
     * @param issues the issues to be appointed to the different sections.
     * @param versionComparator the comparator to use to sort version numbers. A
     *          value of <code>null</code> implies that natural sort order is to
     *          be used.
     */
    public VersionedSectioner(final RendererConfig config,
        final List<TaskData> issues,
        final Comparator<ArtifactVersion> versionComparator)
    {
      this.config = config;
      this.issues = issues;
      this.versions = new Versions(config.getSections(), versionComparator);
    }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Distributes the issues to the configured sections within their versions.
    * Issues not defining the property referenced by
    * {@link RendererConfig#getSectionType()} are skipped as well as issues that
    * provide a value for that property that is not part of
    * {@link RendererConfig#getSections()}. If the issue has no version attribute
    * (target milestone), the issue is also skipped.
    *
    * @impl Skipped issues are logged at debug level.
    * @return the map of versions.
    */
   public Versions run()
   {
     final String sectionAttributeKey = config.getSectionType();
     final BugzillaAttribute versionAttribute =
         BugzillaAttribute.TARGET_MILESTONE;
     for (TaskData issue : issues)
     {
       final TaskAttribute root = issue.getRoot();
       final ArtifactVersion version = getVersion(root, versionAttribute);
       if (version != null)
       {
         final TaskAttribute attribute = root.getAttribute(sectionAttributeKey);
         if (attribute != null)
         {
           final String section = attribute.getValue();
           final boolean added = versions.add(version, section, issue);
           if (!added && LOG.isDebugEnabled())
           {
             LOG.debug("Issue #" + issue.getTaskId() + " defines attribute '"
                       + sectionAttributeKey + "' as '" + section
                       + "' which is not mapped to a column. Skipped.");
           }
         }
         else
         {
           logSkipping(sectionAttributeKey, issue);
         }
       }
       else
       {
         logSkipping(versionAttribute.getKey(), issue);
       }
     }
     return versions;
   }
 
   /**
    * Simple helper to log that the given issue was skipped due to a missing
    * attribute of this issue.
    * <p>
    * Logging is run on debug level.
    * </p>
    *
    * @param attributeKey the key of the attribute that was not set and therefore
    *          the issue was skipped.
    * @param issue the skipped issue.
    */
   private static void logSkipping(final String attributeKey,
       final TaskData issue)
   {
     if (LOG.isDebugEnabled())
     {
       LOG.debug("Issue #" + issue.getTaskId() + " does not define attribute '"
                 + attributeKey + "'. Skipped.");
     }
   }
 
   /**
    * Returns the value for the version referenced by the
    * <code>versionAttribute</code>. The value of this attribute is required to
    * be a version information. Bugzilla supports the version and target
    * milestone as version values.
    *
    * @param rootAttribute the reference to the issues root attribute.
    * @param versionAttributeDescriptor the key to the attribute to fetch within
    *          the root attribute.
    * @return the version instance created upon the version attribute's value or
    *         <code>null</code> if that information was not present or not valid.
    */
   private ArtifactVersion getVersion(final TaskAttribute rootAttribute,
       final BugzillaAttribute versionAttributeDescriptor)
   {
     final TaskAttribute attribute =
         rootAttribute.getAttribute(versionAttributeDescriptor.getKey());
     if (attribute != null)
     {
       final String versionString = attribute.getValue();
       if (versionString != null && !"---".equals(versionString))
       {
         final ArtifactVersion version =
             config.getVersionFactoryInstance().createVersion(versionString);
         return version;
       }
     }
     return null;
   }
 
   // --- object basics --------------------------------------------------------
 
 }