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.model.ArtifactReference;
  import org.apache.archiva.repository.ManagedRepositoryContent;
  import org.apache.archiva.repository.content.PathParser;
  import org.apache.archiva.repository.layout.LayoutException;
  import org.apache.archiva.repository.metadata.MetadataTools;
  import org.apache.commons.lang.StringUtils;
  
  /**
   * RepositoryRequest is used to determine the type of request that is incoming, and convert it to an appropriate
   * ArtifactReference.
   */
  public class RepositoryRequest
  {
      private PathParser defaultPathParser = new DefaultPathParser();
  
      public RepositoryRequest()
      {
          // no op
      }
  
      /**
       * Takes an incoming requested path (in "/" format) and gleans the layout
       * and ArtifactReference appropriate for that content.
       *
       * @param requestedPath the relative path to the content.
       * @return the ArtifactReference for the requestedPath.
       * @throws org.apache.archiva.repository.layout.LayoutException if the request path is not layout valid.
       */
      public ArtifactReference toArtifactReference( String requestedPath )
          throws LayoutException
      {
          if ( StringUtils.isBlank( requestedPath ) )
          {
              throw new LayoutException( "Blank request path is not a valid." );
          }
  
          String path = requestedPath;
          while ( path.startsWith( "/" ) )
          {
              path = path.substring( 1 );
  
              // Only slash? that's bad, mmm-kay?
              if ( "/".equals( path ) )
              {
                  throw new LayoutException( "Invalid request path: Slash only." );
              }
          }
  
          if ( isDefault( path ) )
          {
              return defaultPathParser.toArtifactReference( path );
          }
          else if ( isLegacy( path ) )
          {
              throw new LayoutException( "Legacy Maven1 repository not supported anymore." );
          }
          else
          {
              throw new LayoutException( "Not a valid request path layout, too short." );
          }
      }
  
      /**
       * <p>
       * Tests the path to see if it conforms to the expectations of a metadata request.
       * </p>
       * <p>
       * NOTE: This does a cursory check on the path's last element.  A result of true
       * from this method is not a guarantee that the metadata is in a valid format, or
       * that it even contains data.
       * </p>
       *
       * @param requestedPath the path to test.
       * @return true if the requestedPath is likely a metadata request.
       */
      public boolean isMetadata( String requestedPath )
      {
          return requestedPath.endsWith( "/" + MetadataTools.MAVEN_METADATA );
     }
 
     /**
      * @param requestedPath
      * @return true if the requestedPath is likely an archetype catalog request.
      */
     public boolean isArchetypeCatalog( String requestedPath )
     {
         return requestedPath.endsWith( "/" + MetadataTools.MAVEN_ARCHETYPE_CATALOG );
     }
 
     /**
      * <p>
      * Tests the path to see if it conforms to the expectations of a support file request.
      * </p>
      * <p>
      * Tests for <code>.sha1</code>, <code>.md5</code>, <code>.asc</code>, and <code>.php</code>.
      * </p>
      * <p>
      * NOTE: This does a cursory check on the path's extension only.  A result of true
      * from this method is not a guarantee that the support resource is in a valid format, or
      * that it even contains data.
      * </p>
      *
      * @param requestedPath the path to test.
      * @return true if the requestedPath is likely that of a support file request.
      */
     public boolean isSupportFile( String requestedPath )
     {
         int idx = requestedPath.lastIndexOf( '.' );
         if ( idx <= 0 )
         {
             return false;
         }
 
         String ext = requestedPath.substring( idx );
         return ( ".sha1".equals( ext ) || ".md5".equals( ext ) || ".asc".equals( ext ) || ".pgp".equals( ext ) );
     }
 
     public boolean isMetadataSupportFile( String requestedPath )
     {
         if ( isSupportFile( requestedPath ) )
         {
             String basefilePath = StringUtils.substring( requestedPath, 0, requestedPath.lastIndexOf( '.' ) );
             if ( isMetadata( basefilePath ) )
             {
                 return true;
             }
         }
 
         return false;
     }
 
     /**
      * <p>
      * Tests the path to see if it conforms to the expectations of a default layout request.
      * </p>
      * <p>
      * NOTE: This does a cursory check on the count of path elements only.  A result of
      * true from this method is not a guarantee that the path sections are valid and
      * can be resolved to an artifact reference.  use {@link #toArtifactReference(String)}
      * if you want a more complete analysis of the validity of the path.
      * </p>
      *
      * @param requestedPath the path to test.
      * @return true if the requestedPath is likely that of a default layout request.
      */
     public boolean isDefault( String requestedPath )
     {
         if ( StringUtils.isBlank( requestedPath ) )
         {
             return false;
         }
 
         String pathParts[] = StringUtils.splitPreserveAllTokens( requestedPath, '/' );
         if ( pathParts.length > 3 )
         {
             return true;
         }
         else if ( pathParts.length == 3 )
         {
             // check if artifact-level metadata (ex. eclipse/jdtcore/maven-metadata.xml)
             if ( isMetadata( requestedPath ) )
             {
                 return true;
             }
             else
             {
                 // check if checksum of artifact-level metadata (ex. eclipse/jdtcore/maven-metadata.xml.sha1)
                 int idx = requestedPath.lastIndexOf( '.' );
                 if ( idx > 0 )
                 {
                     String base = requestedPath.substring( 0, idx );
                     if ( isMetadata( base ) && isSupportFile( requestedPath ) )
                     {
                         return true;
                     }
                 }
 
                 return false;
             }
         }
         else
         {
             return false;
         }
     }
 
     /**
      * <p>
      * Tests the path to see if it conforms to the expectations of a legacy layout request.
      * </p>
      * <p>
      * NOTE: This does a cursory check on the count of path elements only.  A result of
      * true from this method is not a guarantee that the path sections are valid and
      * can be resolved to an artifact reference.  use {@link #toArtifactReference(String)}
      * if you want a more complete analysis of the validity of the path.
      * </p>
      *
      * @param requestedPath the path to test.
      * @return true if the requestedPath is likely that of a legacy layout request.
      */
     public boolean isLegacy( String requestedPath )
     {
         if ( StringUtils.isBlank( requestedPath ) )
         {
             return false;
         }
 
         String pathParts[] = StringUtils.splitPreserveAllTokens( requestedPath, '/' );
         return pathParts.length == 3;
     }
 
     /**
      * Adjust the requestedPath to conform to the native layout of the provided {@link org.apache.archiva.repository.ManagedRepositoryContent}.
      *
      * @param requestedPath the incoming requested path.
      * @param repository    the repository to adjust to.
      * @return the adjusted (to native) path.
      * @throws org.apache.archiva.repository.layout.LayoutException if the path cannot be parsed.
      */
     public String toNativePath( String requestedPath, ManagedRepositoryContent repository )
         throws LayoutException
     {
         if ( StringUtils.isBlank( requestedPath ) )
         {
             throw new LayoutException( "Request Path is blank." );
         }
 
         String referencedResource = requestedPath;
         // No checksum by default.
         String supportfile = "";
 
         // Figure out support file, and actual referencedResource.
         if ( isSupportFile( requestedPath ) )
         {
             int idx = requestedPath.lastIndexOf( '.' );
             referencedResource = requestedPath.substring( 0, idx );
             supportfile = requestedPath.substring( idx );
         }
 
         if ( isMetadata( referencedResource ) )
         {
             /* Nothing to translate.
              * Default layout is the only layout that can contain maven-metadata.xml files, and
              * if the managedRepository is layout legacy, this request would never occur.
              */
             return requestedPath;
         }
 
         // Treat as an artifact reference.
         ArtifactReference ref = toArtifactReference( referencedResource );
         String adjustedPath = repository.toPath( ref );
         return adjustedPath + supportfile;
     }
 }