/*
    * Copyright 2012-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.properties.reports;
  
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.List;
  
  import javax.annotation.concurrent.NotThreadSafe;
  
  import org.jdom.Document;
  import org.jdom.Element;
  
  import de.smartics.properties.api.core.annotations.PropertyUse.UseType;
  import de.smartics.properties.api.core.domain.DocumentMetaData;
  import de.smartics.properties.api.core.domain.PropertyCategories;
  import de.smartics.properties.api.core.domain.PropertyConstraint;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyKey;
  import de.smartics.properties.api.core.domain.PropertyType;
  import de.smartics.properties.api.core.domain.PropertyValueComment;
  import de.smartics.properties.api.core.domain.PropertyValueRange;
  import de.smartics.properties.api.core.domain.SourceInfo;
  import de.smartics.properties.report.data.PropertyReportItem;
  import de.smartics.properties.utils.HtmlUtils;
  
  /**
   * Helper to construct a projectdoc property document.
   */
  @NotThreadSafe
  class XmlPropertyReporter extends AbstractReporter
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The namespace of the document that is created.
     */
    private static final String NAMESPACE =
        "http://www.smartics.de/schema/projectdoc/doctype/property/1";
  
    // --- members --------------------------------------------------------------
  
    /**
     * The information to be set to the report.
     */
    private final PropertyReportItem reportItem;
  
    /**
     * The helper to cleanup HTML fragments.
     */
    private final HtmlUtils htmlUtils;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    XmlPropertyReporter(final String encoding, final PropertyReportItem reportItem)
    {
      super(NAMESPACE);
      this.htmlUtils = new HtmlUtils(encoding);
      this.reportItem = reportItem;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    void write(final OutputStream out) throws IOException
    {
      final Document document = buildDocument("property");
  
      renderPropertyMetadata();
      renderPropertyDescriptor();
      renderValue();
      renderImplementation();
  
      writeXml(out, document);
    }
 
   private void renderPropertyMetadata()
   {
     final String propertySet = reportItem.getPropertySet();
     addElement(rootElement, "propertySet", propertySet);
   }
 
   private void renderPropertyDescriptor()
   {
     final PropertyDescriptor descriptor = reportItem.getDescriptor();
     if (descriptor != null)
     {
       final PropertyKey key = descriptor.getKey();
       addElement(rootElement, "name", key);
       final PropertyType type = descriptor.getType();
       addElement(rootElement, "type", type.toString()); // NOPMD
       final UseType useType = descriptor.getUseType();
       addElement(rootElement, "useType", useType);
       addCategories(descriptor);
 
       final String cleanComment = htmlUtils.cleanHtmlAndJavadoc(getComment());
       writeSpecification(cleanComment);
 
       final String expression =
           descriptor.getDefaultExpression().getExpression();
       if (expression != null)
       {
         if (!expression.contains("${"))
         {
           addElement(rootElement, "defaultValue", expression);
         }
         else
         {
           addElement(rootElement, "defaultExpression", expression);
         }
       }
 
       addRanges(descriptor);
 
       addRestrictions(descriptor);
     }
   }
 
   private void addRanges(final PropertyDescriptor descriptor)
   {
     final PropertyValueRange<?> range = descriptor.getValueRange();
     if (range != null)
     {
       final Element valueRangeElement = new Element("valueRange", ns);
       final PropertyValueComment valueComment = reportItem.getValueComment();
       if (valueComment == null)
       {
         return;
       }
       final String summary =
           htmlUtils.cleanHtmlAndJavadoc(valueComment.getSummary());
       addElement(valueRangeElement, "summary", summary);
 
       final List<?> values = range.getValues();
       for (final Object value : values)
       {
         final String description =
             htmlUtils.cleanHtmlAndJavadoc(valueComment.getValueComment(value));
         final Element element = new Element("element", ns);
 
         addElement(element, "value", value);
         addElement(element, "description", description);
 
         valueRangeElement.addContent(element);
       }
 
       rootElement.addContent(valueRangeElement);
     }
   }
 
   private void addRestrictions(final PropertyDescriptor descriptor)
   {
     final List<? extends PropertyConstraint<?>> constraints =
         descriptor.getConstraints();
     if (!constraints.isEmpty())
     {
       final Element valueContraintsElement =
           new Element("valueConstraints", ns);
 
       for (final PropertyConstraint<?> constraint : constraints)
       {
         final Element element = new Element("constraint", ns);
 
         final String type = constraint.getClass().getName();
         addElement(element, "type", type);
 
         final String description =
             htmlUtils.cleanHtmlAndJavadoc(constraint.getDescription());
         addElement(element, "description", description);
 
         valueContraintsElement.addContent(element);
       }
 
       rootElement.addContent(valueContraintsElement);
     }
   }
 
   private void addCategories(final PropertyDescriptor descriptor)
   {
     final PropertyCategories categories = descriptor.getCategories();
     final Element categoriesElement = new Element("propertyCategories", ns);
 
     for (final Class<?> category : categories.getCategories())
     {
       final String categoryType = category.getName();
       addElement(categoriesElement, "propertyCategory", categoryType);
     }
 
     rootElement.addContent(categoriesElement);
   }
 
   private void addElement(final Element rootElement, final String gi,
       final Object value)
   {
     if (value != null)
     {
       addElement(rootElement, gi, String.valueOf(value));
     }
   }
 
   private void renderValue()
   {
     final Object value = reportItem.getValue();
     if (value != null)
     {
       addElement(rootElement, "value", value);
     }
   }
 
   private void renderImplementation()
   {
     final SourceInfo sourceInfo = reportItem.getSourceInfo();
     if (sourceInfo != null && sourceInfo != SourceInfo.EMPTY)
     {
       final Element implementationElement = new Element("implementation", ns);
 
       final String type = sourceInfo.getElementTypeName();
       addElement(implementationElement, "type", type);
 
       final String field = sourceInfo.getElementName();
       addElement(implementationElement, "field", field);
 
       final int lineNumber = sourceInfo.getLineNumber();
       addElement(implementationElement, "lineNumber",
           String.valueOf(lineNumber));
 
       rootElement.addContent(implementationElement);
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.properties.reports.AbstractReporter#getMetaData()
    */
   @Override
   protected DocumentMetaData getMetaData()
   {
     return reportItem.getMetaData();
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.properties.reports.AbstractReporter#getComment()
    */
   @Override
   protected String getComment()
   {
     final String comment =
         htmlUtils.cleanHtmlAndJavadoc(reportItem.getCommentText());
     return comment;
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.properties.reports.AbstractReporter#getName()
    */
   @Override
   protected String getName()
   {
     return reportItem.getName();
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.properties.reports.AbstractReporter#getSpace()
    */
   @Override
   protected String getSpace()
   {
     return reportItem.getSpace();
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.properties.reports.AbstractReporter#getTitle()
    */
   @Override
   protected String getTitle()
   {
     return reportItem.getTitle();
   }
 
   // --- object basics --------------------------------------------------------
 
 }