package org.apache.archiva.repository.metadata.base;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import org.apache.archiva.model.ArchivaRepositoryMetadata;
  import org.apache.archiva.model.Plugin;
  import org.apache.archiva.repository.metadata.RepositoryMetadataException;
  import org.apache.archiva.repository.storage.StorageAsset;
  import org.apache.archiva.xml.XMLException;
  import org.apache.archiva.xml.XMLWriter;
  import org.apache.archiva.xml.XmlUtil;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  import javax.xml.parsers.ParserConfigurationException;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  
  /**
   * RepositoryMetadataWriter
   */
  public class RepositoryMetadataWriter
  {
      private static final Logger log = LoggerFactory.getLogger(RepositoryMetadataWriter.class);
  
      public static void write( ArchivaRepositoryMetadata metadata, StorageAsset outputFile )
          throws RepositoryMetadataException
      {
          boolean thrown = false;
          try (OutputStreamWriter writer = new OutputStreamWriter( outputFile.getWriteStream(true)))
          {
              write( metadata, writer );
              writer.flush();
          }
          catch ( IOException e )
          {
              thrown = true;
              throw new RepositoryMetadataException(
                  "Unable to write metadata file: " + outputFile.getPath() + " - " + e.getMessage(), e );
          }
          finally
          {
              if ( thrown )
              {
                  try {
                      outputFile.getStorage().removeAsset(outputFile);
                  } catch (IOException e) {
                      log.error("Could not remove asset {}", outputFile);
                  }
              }
          }
      }
  
      public static void write( ArchivaRepositoryMetadata metadata, Writer writer )
          throws RepositoryMetadataException
      {
          Document doc = null;
          try {
              doc = XmlUtil.createDocument();
          } catch (ParserConfigurationException e) {
              throw new RepositoryMetadataException("Could not create xml doc " + e.getMessage(), e);
          }
  
          Element root = doc.createElement( "metadata" );
          doc.appendChild(root);
  
          addOptionalElementText( root, "groupId", metadata.getGroupId() );
          addOptionalElementText( root, "artifactId", metadata.getArtifactId() );
          addOptionalElementText( root, "version", metadata.getVersion() );
  
          if ( CollectionUtils.isNotEmpty( metadata.getPlugins() ) )
          {
              Element plugins = XmlUtil.addChild(root, "plugins" );
 
             List<Plugin> pluginList = metadata.getPlugins();
             Collections.sort( pluginList, PluginComparator.INSTANCE );
 
             for ( Plugin plugin : metadata.getPlugins() )
             {
                 Element p = XmlUtil.addChild(plugins, "plugin" );
                 XmlUtil.addChild(doc, p, "prefix" ).setTextContent( plugin.getPrefix() );
                 XmlUtil.addChild(doc, p, "artifactId" ).setTextContent( plugin.getArtifactId() );
                 addOptionalElementText( p, "name", plugin.getName() );
             }
         }
 
         if ( CollectionUtils.isNotEmpty( metadata.getAvailableVersions() ) //
             || StringUtils.isNotBlank( metadata.getReleasedVersion() ) //
             || StringUtils.isNotBlank( metadata.getLatestVersion() ) //
             || StringUtils.isNotBlank( metadata.getLastUpdated() ) //
             || ( metadata.getSnapshotVersion() != null ) )
         {
             Element versioning = XmlUtil.addChild(root, "versioning" );
 
             addOptionalElementText( versioning, "latest", metadata.getLatestVersion() );
             addOptionalElementText( versioning, "release", metadata.getReleasedVersion() );
 
             if ( metadata.getSnapshotVersion() != null )
             {
                 Element snapshot = XmlUtil.addChild(versioning, "snapshot" );
                 String bnum = String.valueOf( metadata.getSnapshotVersion().getBuildNumber() );
                 addOptionalElementText( snapshot, "buildNumber", bnum );
                 addOptionalElementText( snapshot, "timestamp", metadata.getSnapshotVersion().getTimestamp() );
             }
 
             if ( CollectionUtils.isNotEmpty( metadata.getAvailableVersions() ) )
             {
                 Element versions = XmlUtil.addChild(versioning, "versions" );
                 Iterator<String> it = metadata.getAvailableVersions().iterator();
                 while ( it.hasNext() )
                 {
                     String version = it.next();
                     XmlUtil.addChild(versions, "version" ).setTextContent( version );
                 }
             }
 
             addOptionalElementText( versioning, "lastUpdated", metadata.getLastUpdated() );
         }
 
         try
         {
             XMLWriter.write( doc, writer );
         }
         catch ( XMLException e )
         {
             throw new RepositoryMetadataException( "Unable to write xml contents to writer: " + e.getMessage(), e );
         }
     }
 
     private static void addOptionalElementText( Element elem, String elemName, String text )
     {
         if ( StringUtils.isBlank( text ) )
         {
             return;
         }
 
         XmlUtil.addChild(elem, elemName ).setTextContent( text );
     }
 
     private static class PluginComparator
         implements Comparator<Plugin>
     {
         private static final PluginComparator INSTANCE = new PluginComparator();
 
         @Override
         public int compare( Plugin="../../../../../../org/apache/archiva/model/Plugin.html#Plugin">Plugin plugin, Plugin plugin2 )
         {
             if ( plugin.getPrefix() != null && plugin2.getPrefix() != null )
             {
                 return plugin.getPrefix().compareTo( plugin2.getPrefix() );
             }
             if ( plugin.getName() != null && plugin2.getName() != null )
             {
                 return plugin.getName().compareTo( plugin2.getName() );
             }
             // we assume artifactId is not null which sounds good :-)
             return plugin.getArtifactId().compareTo( plugin2.getArtifactId() );
         }
     }
 }