/*
    * Copyright 2008-2010 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.cache;
  
  import java.io.Closeable;
  import java.util.Map;
  
  import javax.xml.stream.XMLStreamException;
  import javax.xml.stream.XMLStreamWriter;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
  import org.eclipse.mylyn.tasks.core.data.TaskAttributeMetaData;
  import org.eclipse.mylyn.tasks.core.data.TaskData;
  
  /**
   * Writes a single task to a stream.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public class XmlTaskWriter implements TaskWriter, Closeable
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private final Log log = LogFactory.getLog(XmlTaskWriter.class);
  
    /**
     * The writer to write the single tasks to.
     */
    protected final XMLStreamWriter xmlWriter;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param xmlWriter the writer to write the single tasks to.
     * @throws NullPointerException if the <code>xmlWriter</code> is
     *           <code>null</code>.
     */
    public XmlTaskWriter(final XMLStreamWriter xmlWriter)
      throws NullPointerException
    {
      if (xmlWriter == null)
      {
        throw new NullPointerException("XML writer must not be 'null'.");
      }
  
      this.xmlWriter = xmlWriter;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * {@inheritDoc}
     *
     * @see de.smartics.maven.issues.cache.TaskWriter#writeTask(org.eclipse.mylyn.tasks.core.data.TaskData)
     */
    public void writeTask(final TaskData task) throws XMLStreamException
    {
      xmlWriter.writeStartElement(TaskInfoKey.TASK_DATA);
      writeValueAsAttributeIfNotNull(TaskInfoKey.TASK_ID, task.getTaskId());
      writeValueAsAttributeIfNotNull(TaskInfoKey.CONNECTOR_KIND,
          task.getConnectorKind());
      writeValueAsAttributeIfNotNull(TaskInfoKey.VERSION, task.getVersion());
      writeValueAsAttributeIfNotNull(TaskInfoKey.REPOSITORY_URL,
         task.getRepositoryUrl());
     writeAttribute(task.getRoot());
     xmlWriter.writeEndElement();
   }
 
   /**
    * Writes the given value as XML attribute value if this value is not
    * <code>null</code>.
    *
    * @param name the name of the XML attribute to write.
    * @param value the value for the XML attribute to write.
    * @throws XMLStreamException if the writing of the XML attribute failed.
    */
   private void writeValueAsAttributeIfNotNull(final String name,
       final String value) throws XMLStreamException
   {
     if (value != null)
     {
       xmlWriter.writeAttribute(name, value);
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.maven.issues.cache.TaskWriter#writeAttribute(org.eclipse.mylyn.tasks.core.data.TaskAttribute)
    */
   public void writeAttribute(final TaskAttribute attribute)
     throws XMLStreamException
   {
     if (attribute != null)
     {
       xmlWriter.writeStartElement(TaskInfoKey.ATTRIBUTE);
       xmlWriter.writeAttribute(TaskInfoKey.ATTRIBUTE_ID, attribute.getId());
 
       writeAttributeValues(attribute);
       writeAttributes(attribute.getAttributes());
       final TaskAttributeMetaData metaData = attribute.getMetaData();
       if (metaData != null)
       {
         writeMap(TaskInfoKey.META_DATA, metaData.getValues());
       }
       writeMap(TaskInfoKey.OPTIONS, attribute.getOptions());
 
       xmlWriter.writeEndElement();
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.maven.issues.cache.TaskWriter#writeAttributes(java.util.Map)
    */
   public void writeAttributes(final Map<String, TaskAttribute> attributes)
     throws XMLStreamException
   {
     if (attributes != null && !attributes.values().isEmpty())
     {
       xmlWriter.writeStartElement(TaskInfoKey.ATTRIBUTES);
       for (TaskAttribute attribute : attributes.values())
       {
         writeAttribute(attribute);
       }
       xmlWriter.writeEndElement();
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.maven.issues.cache.TaskWriter#writeAttributeValues(org.eclipse.mylyn.tasks.core.data.TaskAttribute)
    */
   public void writeAttributeValues(final TaskAttribute attribute)
     throws XMLStreamException
   {
     if (attribute != null && !attribute.getValues().isEmpty())
     {
       xmlWriter.writeStartElement(TaskInfoKey.VALUES);
       for (String value : attribute.getValues())
       {
         writeSimpleElement(TaskInfoKey.VALUE, value);
       }
       xmlWriter.writeEndElement();
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.maven.issues.cache.TaskWriter#writeMap(java.lang.String,
    *      java.util.Map)
    */
   public void writeMap(final String gi, final Map<String, String> map)
     throws XMLStreamException
   {
     if (map != null && !map.isEmpty())
     {
       xmlWriter.writeStartElement(gi);
       for (Map.Entry<String, String> entry : map.entrySet())
       {
         xmlWriter.writeStartElement(TaskInfoKey.ENTRY);
         writeSimpleElement(TaskInfoKey.KEY, entry.getKey());
         writeSimpleElement(TaskInfoKey.VALUE, entry.getValue());
         xmlWriter.writeEndElement();
       }
       xmlWriter.writeEndElement();
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.maven.issues.cache.TaskWriter#writeSimpleElement(java.lang.String,
    *      java.lang.String)
    */
   public void writeSimpleElement(final String gi, final String content)
     throws XMLStreamException
   {
     xmlWriter.writeStartElement(gi);
     xmlWriter.writeCharacters(content);
     xmlWriter.writeEndElement();
   }
 
   /**
    * Closes this stream and releases any system resources associated with it. If
    * the stream is already closed then invoking this method has no effect.
    * <p>
    * The stream is closed quietly, logging any failure at error level.
    * </p>
    *
    * @see java.io.Closeable#close()
    */
   public void close()
   {
     try
     {
       this.xmlWriter.close();
     }
     catch (final XMLStreamException e)
     {
       if (log.isErrorEnabled())
       {
         log.error("Cannot close XML stream of task writer.");
       }
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }