package org.eclipse.aether.internal.test.util;
   
   /*
    * 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.HashSet;
  import java.util.Set;
  
  import org.eclipse.aether.RepositorySystemSession;
  import org.eclipse.aether.artifact.Artifact;
  import org.eclipse.aether.metadata.Metadata;
  import org.eclipse.aether.repository.LocalArtifactRegistration;
  import org.eclipse.aether.repository.LocalArtifactRequest;
  import org.eclipse.aether.repository.LocalArtifactResult;
  import org.eclipse.aether.repository.LocalMetadataRegistration;
  import org.eclipse.aether.repository.LocalMetadataRequest;
  import org.eclipse.aether.repository.LocalMetadataResult;
  import org.eclipse.aether.repository.LocalRepository;
  import org.eclipse.aether.repository.LocalRepositoryManager;
  import org.eclipse.aether.repository.RemoteRepository;
  
  import static java.util.Objects.requireNonNull;
  
  /**
   * A simplistic local repository manager that uses a temporary base directory.
   */
  public class TestLocalRepositoryManager
      implements LocalRepositoryManager
  {
  
      private LocalRepository localRepository;
  
      private final Set<Artifact> unavailableArtifacts = new HashSet<>();
  
      private final Set<Artifact> artifactRegistrations = new HashSet<>();
  
      private final Set<Metadata> metadataRegistrations = new HashSet<>();
  
      public TestLocalRepositoryManager()
      {
          try
          {
              localRepository = new LocalRepository( TestFileUtils.createTempDir( "test-local-repo" ) );
          }
          catch ( IOException e )
          {
              throw new IllegalStateException( e );
          }
      }
  
      public LocalRepository getRepository()
      {
          return localRepository;
      }
  
      public String getPathForLocalArtifact( Artifact artifact )
      {
          requireNonNull( artifact, "artifact cannot be null" );
  
          String artifactId = artifact.getArtifactId();
          String groupId = artifact.getGroupId();
          String extension = artifact.getExtension();
          String version = artifact.getVersion();
          String classifier = artifact.getClassifier();
  
          return String.format( "%s/%s/%s/%s-%s-%s%s.%s", groupId, artifactId, version, groupId, artifactId, version,
                         classifier, extension );
      }
  
      public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context )
      {
          requireNonNull( artifact, "artifact cannot be null" );
          requireNonNull( repository, "repository cannot be null" );
  
          return getPathForLocalArtifact( artifact );
      }
  
      public String getPathForLocalMetadata( Metadata metadata )
      {
          requireNonNull( metadata, "metadata cannot be null" );
  
         String artifactId = metadata.getArtifactId();
         String groupId = metadata.getGroupId();
         String version = metadata.getVersion();
         return String.format( "%s/%s/%s/%s-%s-%s.xml", groupId, artifactId, version, groupId, artifactId, version );
     }
 
     public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context )
     {
         requireNonNull( metadata, "metadata cannot be null" );
         requireNonNull( repository, "repository cannot be null" );
 
         return getPathForLocalMetadata( metadata );
     }
 
     public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request )
     {
         requireNonNull( session, "session cannot be null" );
         requireNonNull( request, "request cannot be null" );
 
         Artifact artifact = request.getArtifact();
 
         LocalArtifactResult result = new LocalArtifactResult( request );
         File file = new File( localRepository.getBasedir(), getPathForLocalArtifact( artifact ) );
         result.setFile( file.isFile() ? file : null );
         result.setAvailable( file.isFile() && !unavailableArtifacts.contains( artifact ) );
 
         return result;
     }
 
     public void add( RepositorySystemSession session, LocalArtifactRegistration request )
     {
         requireNonNull( session, "session cannot be null" );
         requireNonNull( request, "request cannot be null" );
 
         artifactRegistrations.add( request.getArtifact() );
     }
 
     public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request )
     {
         requireNonNull( session, "session cannot be null" );
         requireNonNull( request, "request cannot be null" );
 
         Metadata metadata = request.getMetadata();
 
         LocalMetadataResult result = new LocalMetadataResult( request );
         File file = new File( localRepository.getBasedir(), getPathForLocalMetadata( metadata ) );
         result.setFile( file.isFile() ? file : null );
 
         return result;
     }
 
     public void add( RepositorySystemSession session, LocalMetadataRegistration request )
     {
         requireNonNull( session, "session cannot be null" );
         requireNonNull( request, "request cannot be null" );
 
         metadataRegistrations.add( request.getMetadata() );
     }
 
     public Set<Artifact> getArtifactRegistration()
     {
         return artifactRegistrations;
     }
 
     public Set<Metadata> getMetadataRegistration()
     {
         return metadataRegistrations;
     }
 
     public void setArtifactAvailability( Artifact artifact, boolean available )
     {
         if ( available )
         {
             unavailableArtifacts.remove( artifact );
         }
         else
         {
             unavailableArtifacts.add( artifact );
         }
     }
 
 }