package org.apache.archiva.repository.content.maven2;
   
   /*
    * 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.admin.model.beans.ManagedRepository;
  import org.apache.archiva.common.utils.PathUtil;
  import org.apache.archiva.configuration.FileTypes;
  import org.apache.archiva.metadata.repository.storage.maven2.DefaultArtifactMappingProvider;
  import org.apache.archiva.model.ArchivaArtifact;
  import org.apache.archiva.model.ArtifactReference;
  import org.apache.archiva.model.ProjectReference;
  import org.apache.archiva.model.VersionedReference;
  import org.apache.archiva.repository.ContentNotFoundException;
  import org.apache.archiva.repository.ManagedRepositoryContent;
  import org.apache.archiva.repository.RepositoryException;
  import org.apache.archiva.repository.layout.LayoutException;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang.StringUtils;
  import org.springframework.context.annotation.Scope;
  import org.springframework.stereotype.Service;
  
  import javax.inject.Inject;
  import javax.inject.Named;
  import java.io.File;
  import java.io.IOException;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Set;
  
  /**
   * ManagedDefaultRepositoryContent
   */
  @Service ("managedRepositoryContent#default")
  @Scope ("prototype")
  public class ManagedDefaultRepositoryContent
      extends AbstractDefaultRepositoryContent
      implements ManagedRepositoryContent
  {
      @Inject
      @Named ( "fileTypes" )
      private FileTypes filetypes;
  
      private ManagedRepository repository;
  
      public ManagedDefaultRepositoryContent()
      {
          // default to use if there are none supplied as components
          this.artifactMappingProviders = Collections.singletonList( new DefaultArtifactMappingProvider() );
      }
  
      @Override
      public void deleteVersion( VersionedReference reference )
      {
          String path = toMetadataPath( reference );
          File projectPath = new File( getRepoRoot(), path );
  
          File projectDir = projectPath.getParentFile();
          if ( projectDir.exists() && projectDir.isDirectory() )
          {
              FileUtils.deleteQuietly( projectDir );
          }
      }
  
      @Override
      public void deleteProject( String namespace, String projectId )
          throws RepositoryException, ContentNotFoundException
      {
          ArtifactReference artifactReference = new ArtifactReference();
          artifactReference.setGroupId( namespace );
          artifactReference.setArtifactId( projectId );
          String path = toPath( artifactReference );
          File directory = new File( getRepoRoot(), path );
          if ( !directory.exists() )
          {
              throw new ContentNotFoundException( "cannot found project " + namespace + ":" + projectId );
          }
          try {
              if (!directory.getCanonicalPath().equals(directory.getAbsolutePath())) {
                  throw new ContentNotFoundException( "Invalid directory for project " + namespace + ":" + projectId );
              }
          } catch (IOException e) {
              throw new RepositoryException(e.getMessage(), e);
         }
         if ( directory.isDirectory() )
         {
             try
             {
                 FileUtils.deleteDirectory( directory );
             }
             catch ( IOException e )
             {
                 throw new RepositoryException( e.getMessage(), e );
             }
         }
         else
         {
             log.warn( "project {}:{} is not a directory", namespace, projectId );
         }
 
     }
 
     @Override
     public void deleteArtifact( ArtifactReference artifactReference )
     {
         String path = toPath( artifactReference );
         File filePath = new File( getRepoRoot(), path );
 
         if ( filePath.exists() )
         {
             FileUtils.deleteQuietly( filePath );
         }
 
         File filePathmd5 = new File( getRepoRoot(), path + ".md5" );
 
         if ( filePathmd5.exists() )
         {
             FileUtils.deleteQuietly( filePathmd5 );
         }
 
         File filePathsha1 = new File( getRepoRoot(), path + ".sha1" );
 
         if ( filePathsha1.exists() )
         {
             FileUtils.deleteQuietly( filePathsha1 );
         }
     }
 
     @Override
     public void deleteGroupId( String groupId )
         throws ContentNotFoundException
     {
 
         String path = StringUtils.replaceChars( groupId, '.', '/' );
 
         File directory = new File( getRepoRoot(), path );
 
         if ( directory.exists() )
         {
             try
             {
                 FileUtils.deleteDirectory( directory );
             }
             catch ( IOException e )
             {
                 log.warn( "skip error deleting directory {}:", directory.getPath(), e );
             }
         }
     }
 
     @Override
     public String getId()
     {
         return repository.getId();
     }
 
     @Override
     public Set<ArtifactReference> getRelatedArtifacts( ArtifactReference reference )
         throws ContentNotFoundException
     {
         File artifactFile = toFile( reference );
         File repoDir = artifactFile.getParentFile();
 
         if ( !repoDir.exists() )
         {
             throw new ContentNotFoundException(
                 "Unable to get related artifacts using a non-existant directory: " + repoDir.getAbsolutePath() );
         }
 
         if ( !repoDir.isDirectory() )
         {
             throw new ContentNotFoundException(
                 "Unable to get related artifacts using a non-directory: " + repoDir.getAbsolutePath() );
         }
 
         Set<ArtifactReference> foundArtifacts = new HashSet<>();
 
         // First gather up the versions found as artifacts in the managed repository.
         File repoFiles[] = repoDir.listFiles();
         for (File repoFile : repoFiles) 
         {
             if (repoFile.isDirectory()) {
                 // Skip it. it's a directory.
                 continue;
             }
             String relativePath = PathUtil.getRelative(repository.getLocation(), repoFile);
             if ( filetypes.matchesArtifactPattern( relativePath ) )
             {
                 try
                 {
                     ArtifactReference artifact = toArtifactReference( relativePath );
 
                     // Test for related, groupId / artifactId / version must match.
                     if ( artifact.getGroupId().equals( reference.getGroupId() ) && artifact.getArtifactId().equals(
                             reference.getArtifactId() ) && artifact.getVersion().equals( reference.getVersion() ) )
                     {
                         foundArtifacts.add( artifact );
                     }
                 }
                 catch ( LayoutException e )
                 {
                     log.debug( "Not processing file that is not an artifact: {}", e.getMessage() );
                 }
             }
         }
 
         return foundArtifacts;
     }
 
     @Override
     public String getRepoRoot()
     {
         return repository.getLocation();
     }
 
     @Override
     public ManagedRepository getRepository()
     {
         return repository;
     }
 
     /**
      * Gather the Available Versions (on disk) for a specific Project Reference, based on filesystem
      * information.
      *
      * @return the Set of available versions, based on the project reference.
      * @throws org.apache.archiva.repository.layout.LayoutException
      * @throws org.apache.archiva.repository.layout.LayoutException
      */
     @Override
     public Set<String> getVersions( ProjectReference reference )
         throws ContentNotFoundException, LayoutException
     {
         String path = toMetadataPath( reference );
 
         int idx = path.lastIndexOf( '/' );
         if ( idx > 0 )
         {
             path = path.substring( 0, idx );
         }
 
         File repoDir = new File( repository.getLocation(), path );
 
         if ( !repoDir.exists() )
         {
             throw new ContentNotFoundException(
                 "Unable to get Versions on a non-existant directory: " + repoDir.getAbsolutePath() );
         }
 
         if ( !repoDir.isDirectory() )
         {
             throw new ContentNotFoundException(
                 "Unable to get Versions on a non-directory: " + repoDir.getAbsolutePath() );
         }
 
         Set<String> foundVersions = new HashSet<>();
         VersionedReference versionRef = new VersionedReference();
         versionRef.setGroupId( reference.getGroupId() );
         versionRef.setArtifactId( reference.getArtifactId() );
 
         File repoFiles[] = repoDir.listFiles();
         for (File repoFile : repoFiles) 
         {
             if (!repoFile.isDirectory()) {
                 // Skip it. not a directory.
                 continue;
             }
             // Test if dir has an artifact, which proves to us that it is a valid version directory.
             String version = repoFile.getName();
             versionRef.setVersion( version );
             if ( hasArtifact( versionRef ) )
             {
                 // Found an artifact, must be a valid version.
                 foundVersions.add( version );
             }
         }
 
         return foundVersions;
     }
 
     @Override
     public Set<String> getVersions( VersionedReference reference )
         throws ContentNotFoundException
     {
         String path = toMetadataPath( reference );
 
         int idx = path.lastIndexOf( '/' );
         if ( idx > 0 )
         {
             path = path.substring( 0, idx );
         }
 
         File repoDir = new File( repository.getLocation(), path );
 
         if ( !repoDir.exists() )
         {
             throw new ContentNotFoundException(
                 "Unable to get versions on a non-existant directory: " + repoDir.getAbsolutePath() );
         }
 
         if ( !repoDir.isDirectory() )
         {
             throw new ContentNotFoundException(
                 "Unable to get versions on a non-directory: " + repoDir.getAbsolutePath() );
         }
 
         Set<String> foundVersions = new HashSet<>();
 
         // First gather up the versions found as artifacts in the managed repository.
         File repoFiles[] = repoDir.listFiles();
         for (File repoFile : repoFiles) 
         {
             if (repoFile.isDirectory()) {
                 // Skip it. it's a directory.
                 continue;
             }
             String relativePath = PathUtil.getRelative(repository.getLocation(), repoFile);
             if ( filetypes.matchesDefaultExclusions( relativePath ) )
             {
                 // Skip it, it's metadata or similar
                 continue;
             }
             if ( filetypes.matchesArtifactPattern( relativePath ) )
             {
                 try
                 {
                     ArtifactReference artifact = toArtifactReference( relativePath );
 
                     foundVersions.add( artifact.getVersion() );
                 }
                 catch ( LayoutException e )
                 {
                     log.debug( "Not processing file that is not an artifact: {}", e.getMessage() );
                 }
             }
         }
 
         return foundVersions;
     }
 
     @Override
     public boolean hasContent( ArtifactReference reference )
     {
         File artifactFile = toFile( reference );
         return artifactFile.exists() && artifactFile.isFile();
     }
 
     @Override
     public boolean hasContent( ProjectReference reference )
     {
         try
         {
             Set<String> versions = getVersions( reference );
             return !versions.isEmpty();
         }
         catch ( ContentNotFoundException | LayoutException e )
         {
             return false;
         }
     }
 
     @Override
     public boolean hasContent( VersionedReference reference )
     {
         try
         {
             return ( getFirstArtifact( reference ) != null );
         }
         catch ( IOException | LayoutException e )
         {
             return false;
         }
     }
 
     @Override
     public void setRepository( ManagedRepository repository )
     {
         this.repository = repository;
     }
 
     /**
      * Convert a path to an artifact reference.
      *
      * @param path the path to convert. (relative or full location path)
      * @throws org.apache.archiva.repository.layout.LayoutException if the path cannot be converted to an artifact reference.
      */
     @Override
     public ArtifactReference toArtifactReference( String path )
         throws LayoutException
     {
         if ( ( path != null ) && path.startsWith( repository.getLocation() ) && repository.getLocation().length() > 0 )
         {
             return super.toArtifactReference( path.substring( repository.getLocation().length() + 1 ) );
         }
 
         return super.toArtifactReference( path );
     }
 
     @Override
     public File toFile( ArtifactReference reference )
     {
         return new File( repository.getLocation(), toPath( reference ) );
     }
 
     @Override
     public File toFile( ArchivaArtifact reference )
     {
         return new File( repository.getLocation(), toPath( reference ) );
     }
 
     /**
      * Get the first Artifact found in the provided VersionedReference location.
      *
      * @param reference the reference to the versioned reference to search within
      * @return the ArtifactReference to the first artifact located within the versioned reference. or null if
      *         no artifact was found within the versioned reference.
      * @throws java.io.IOException     if the versioned reference is invalid (example: doesn't exist, or isn't a directory)
      * @throws org.apache.archiva.repository.layout.LayoutException
      */
     private ArtifactReference getFirstArtifact( VersionedReference reference )
         throws LayoutException, IOException
     {
         String path = toMetadataPath( reference );
 
         int idx = path.lastIndexOf( '/' );
         if ( idx > 0 )
         {
             path = path.substring( 0, idx );
         }
 
         File repoDir = new File( repository.getLocation(), path );
 
         if ( !repoDir.exists() )
         {
             throw new IOException( "Unable to gather the list of snapshot versions on a non-existant directory: "
                                        + repoDir.getAbsolutePath() );
         }
 
         if ( !repoDir.isDirectory() )
         {
             throw new IOException(
                 "Unable to gather the list of snapshot versions on a non-directory: " + repoDir.getAbsolutePath() );
         }
 
         File repoFiles[] = repoDir.listFiles();
         for (File repoFile : repoFiles) 
         {
             if (repoFile.isDirectory()) {
                 // Skip it. it's a directory.
                 continue;
             }
             String relativePath = PathUtil.getRelative(repository.getLocation(), repoFile);
             if ( filetypes.matchesArtifactPattern( relativePath ) )
             {
                 ArtifactReference artifact = toArtifactReference( relativePath );
 
                 return artifact;
             }
         }
 
         // No artifact was found.
         return null;
     }
 
     private boolean hasArtifact( VersionedReference reference )
         throws LayoutException
     {
         try
         {
             return ( getFirstArtifact( reference ) != null );
         }
         catch ( IOException e )
         {
             return false;
         }
     }
 
     public void setFiletypes( FileTypes filetypes )
     {
         this.filetypes = filetypes;
     }
 }