package org.apache.maven.archiva.consumers.core.repository;

 /*

  * 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 java.io.File;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.List;

 import org.apache.maven.archiva.common.utils.VersionComparator;

 import org.apache.maven.archiva.common.utils.VersionUtil;

 import org.apache.maven.archiva.configuration.ArchivaConfiguration;

 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;

 import org.apache.maven.archiva.model.ArchivaArtifact;

 import org.apache.maven.archiva.model.ArtifactReference;

 import org.apache.maven.archiva.model.ProjectReference;

 import org.apache.maven.archiva.model.VersionedReference;

 import org.apache.maven.archiva.repository.ContentNotFoundException;

 import org.apache.maven.archiva.repository.ManagedRepositoryContent;

 import org.apache.maven.archiva.repository.RepositoryContentFactory;

 import org.apache.maven.archiva.repository.RepositoryException;

 import org.apache.maven.archiva.repository.RepositoryNotFoundException;

 import org.apache.maven.archiva.repository.events.RepositoryListener;

 import org.apache.maven.archiva.repository.layout.LayoutException;

 import org.apache.maven.archiva.repository.metadata.MetadataTools;

 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException;

 /**

  * <p>

  * This will look in a single managed repository, and purge any snapshots that are present

  * that have a corresponding released version on the same repository.

  * </p>

  * 

  * <p>

  * So, if you have the following (presented in the m2/default layout form) ...

  * <pre>

  *   /com/foo/foo-tool/1.0-SNAPSHOT/foo-tool-1.0-SNAPSHOT.jar

  *   /com/foo/foo-tool/1.1-SNAPSHOT/foo-tool-1.1-SNAPSHOT.jar

  *   /com/foo/foo-tool/1.2.1-SNAPSHOT/foo-tool-1.2.1-SNAPSHOT.jar

  *   /com/foo/foo-tool/1.2.1/foo-tool-1.2.1.jar

  *   /com/foo/foo-tool/2.0-SNAPSHOT/foo-tool-2.0-SNAPSHOT.jar

  *   /com/foo/foo-tool/2.0/foo-tool-2.0.jar

  *   /com/foo/foo-tool/2.1-SNAPSHOT/foo-tool-2.1-SNAPSHOT.jar

  * </pre>

  * then the current highest ranked released (non-snapshot) version is 2.0, which means

  * the snapshots from 1.0-SNAPSHOT, 1.1-SNAPSHOT, 1.2.1-SNAPSHOT, and 2.0-SNAPSHOT can

  * be purged.  Leaving 2.1-SNAPSHOT in alone.

  * </p>

  *

  * @version $Id$

  */

 public class CleanupReleasedSnapshotsRepositoryPurge

     extends AbstractRepositoryPurge

 {

     private MetadataTools metadataTools;

     private ArchivaConfiguration archivaConfig;

     private RepositoryContentFactory repoContentFactory;

     public CleanupReleasedSnapshotsRepositoryPurge( ManagedRepositoryContent repository, MetadataTools metadataTools,

                                                     ArchivaConfiguration archivaConfig,

                                                     RepositoryContentFactory repoContentFactory,

                                                     List<RepositoryListener> listeners )

     {

         super( repository, listeners );

         this.metadataTools = metadataTools;

         this.archivaConfig = archivaConfig;

         this.repoContentFactory = repoContentFactory;

     }

     public void process( String path )

         throws RepositoryPurgeException

     {

         try

         {

             File artifactFile = new File( repository.getRepoRoot(), path );

             if ( !artifactFile.exists() )

             {

                 // Nothing to do here, file doesn't exist, skip it.

                 return;

             }

             ArtifactReference artifactRef = repository.toArtifactReference( path );

             if ( !VersionUtil.isSnapshot( artifactRef.getVersion() ) )

             {

                 // Nothing to do here, not a snapshot, skip it.

                 return;

             }

             ProjectReference reference = new ProjectReference();

             reference.setGroupId( artifactRef.getGroupId() );

             reference.setArtifactId( artifactRef.getArtifactId() );

             // Gather up all of the versions.

             List<String> allVersions = new ArrayList<String>( repository.getVersions( reference ) );

             List<ManagedRepositoryConfiguration> repos = archivaConfig.getConfiguration().getManagedRepositories();

             for( ManagedRepositoryConfiguration repo : repos )

             {   

                 if( repo.isReleases() && !repo.getId().equals( repository.getId() ) )

                 {   

                     try

                     {   

                         ManagedRepositoryContent repoContent = repoContentFactory.getManagedRepositoryContent( repo.getId() );                        

                         allVersions.addAll( repoContent.getVersions( reference ) );

                     }

                     catch( RepositoryNotFoundException  e )

                     {

                         // swallow

                     }

                     catch( RepositoryException  e )

                     {

                         // swallow

                     }

                 }

             }

             // Split the versions into released and snapshots.

             List<String> releasedVersions = new ArrayList<String>();

             List<String> snapshotVersions = new ArrayList<String>();

             for ( String version : allVersions )

             {   

                 if ( VersionUtil.isSnapshot( version ) )

                 {

                     snapshotVersions.add( version );

                 }

                 else

                 {

                     releasedVersions.add( version );

                 }

             }

             Collections.sort( allVersions, VersionComparator.getInstance() );

             Collections.sort( releasedVersions, VersionComparator.getInstance() );

             Collections.sort( snapshotVersions, VersionComparator.getInstance() );

             // Now clean out any version that is earlier than the highest released version.

             boolean needsMetadataUpdate = false;

             VersionedReference versionRef = new VersionedReference();

             versionRef.setGroupId( artifactRef.getGroupId() );

             versionRef.setArtifactId( artifactRef.getArtifactId() );

             ArchivaArtifact artifact =

                 new ArchivaArtifact( artifactRef.getGroupId(), artifactRef.getArtifactId(), artifactRef.getVersion(),

                                      artifactRef.getClassifier(), artifactRef.getType(), repository.getId() );

             for ( String version : snapshotVersions )

             {   

                 if( releasedVersions.contains( VersionUtil.getReleaseVersion( version ) ) )

                 {                    

                     versionRef.setVersion( version );

                     repository.deleteVersion( versionRef );

                     // TODO: looks incomplete, might not delete related artifacts?

                     for ( RepositoryListener listener : listeners )

                     {

                         listener.deleteArtifact( repository, artifact );

                     }

                     needsMetadataUpdate = true;

                 }

             }           

             if ( needsMetadataUpdate )

             {

                 updateMetadata( artifactRef );

             }

         }

         catch ( LayoutException e )

         {

             log.debug( "Not processing file that is not an artifact: " + e.getMessage() );

         }

         catch ( ContentNotFoundException e )

         {

             throw new RepositoryPurgeException( e.getMessage(), e );

         }

     }

     private void updateMetadata( ArtifactReference artifact )

     {

         VersionedReference versionRef = new VersionedReference();

         versionRef.setGroupId( artifact.getGroupId() );

         versionRef.setArtifactId( artifact.getArtifactId() );

         versionRef.setVersion( artifact.getVersion() );

         ProjectReference projectRef = new ProjectReference();

         projectRef.setGroupId( artifact.getGroupId() );

         projectRef.setArtifactId( artifact.getArtifactId() );

         try

         {

             metadataTools.updateMetadata( repository, versionRef );

         }

         catch ( ContentNotFoundException e )

         {

             // Ignore. (Just means we have no snapshot versions left to reference).

         }

         catch ( RepositoryMetadataException e )

         {

             // Ignore. 

         }

         catch ( IOException e )

         {

             // Ignore. 

         }

         catch ( LayoutException e )

         {

             // Ignore.

         }

         try

         {

             metadataTools.updateMetadata( repository, projectRef );

         }

         catch ( ContentNotFoundException e )

         {

             // Ignore. (Just means we have no snapshot versions left to reference).

         }

         catch ( RepositoryMetadataException e )

         {

             // Ignore. 

         }

         catch ( IOException e )

         {

             // Ignore. 

         }

         catch ( LayoutException e )

         {

             // Ignore.

         }

     }

 }