package org.apache.maven.index.creator;
   
   /*
    * 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.Arrays;
  import java.util.Collection;
  
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.document.Field.Index;
  import org.apache.lucene.document.Field.Store;
  import org.apache.maven.index.ArtifactAvailablility;
  import org.apache.maven.index.ArtifactContext;
  import org.apache.maven.index.ArtifactInfo;
  import org.apache.maven.index.IndexerField;
  import org.apache.maven.index.IndexerFieldVersion;
  import org.apache.maven.index.MAVEN;
  import org.apache.maven.index.NEXUS;
  import org.apache.maven.index.artifact.Gav;
  import org.apache.maven.index.context.IndexCreator;
  import org.apache.maven.index.locator.JavadocLocator;
  import org.apache.maven.index.locator.Locator;
  import org.apache.maven.index.locator.Sha1Locator;
  import org.apache.maven.index.locator.SignatureLocator;
  import org.apache.maven.index.locator.SourcesLocator;
  import org.apache.maven.model.Model;
  import org.codehaus.plexus.component.annotations.Component;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * A minimal index creator used to provide basic information about Maven artifact. This creator will create the index
   * fast, will not open any file to be fastest as possible but it has some drawbacks: The information gathered by this
   * creator are sometimes based on "best-effort" only, and does not reflect the reality (ie. maven archetype packaging @see
   * {@link MavenArchetypeArtifactInfoIndexCreator}).
   * 
   * @author cstamas
   */
  @Component( role = IndexCreator.class, hint = MinimalArtifactInfoIndexCreator.ID )
  public class MinimalArtifactInfoIndexCreator
      extends AbstractIndexCreator
      implements LegacyDocumentUpdater
  {
      public static final String ID = "min";
  
      /**
       * Info: packaging, lastModified, size, sourcesExists, javadocExists, signatureExists. Stored, not indexed.
       */
      public static final IndexerField FLD_INFO = new IndexerField( NEXUS.INFO, IndexerFieldVersion.V1, "i",
          "Artifact INFO (not indexed, stored)", Store.YES, Index.NO );
  
      public static final IndexerField FLD_GROUP_ID_KW = new IndexerField( MAVEN.GROUP_ID, IndexerFieldVersion.V1, "g",
          "Artifact GroupID (as keyword)", Store.NO, Index.NOT_ANALYZED );
  
      public static final IndexerField FLD_GROUP_ID = new IndexerField( MAVEN.GROUP_ID, IndexerFieldVersion.V3,
          "groupId", "Artifact GroupID (tokenized)", Store.NO, Index.ANALYZED );
  
      public static final IndexerField FLD_ARTIFACT_ID_KW = new IndexerField( MAVEN.ARTIFACT_ID, IndexerFieldVersion.V1,
          "a", "Artifact ArtifactID (as keyword)", Store.NO, Index.NOT_ANALYZED );
  
      public static final IndexerField FLD_ARTIFACT_ID = new IndexerField( MAVEN.ARTIFACT_ID, IndexerFieldVersion.V3,
          "artifactId", "Artifact ArtifactID (tokenized)", Store.NO, Index.ANALYZED );
  
      public static final IndexerField FLD_VERSION_KW = new IndexerField( MAVEN.VERSION, IndexerFieldVersion.V1, "v",
          "Artifact Version (as keyword)", Store.NO, Index.NOT_ANALYZED );
  
      public static final IndexerField FLD_VERSION = new IndexerField( MAVEN.VERSION, IndexerFieldVersion.V3, "version",
          "Artifact Version (tokenized)", Store.NO, Index.ANALYZED );
  
      public static final IndexerField FLD_PACKAGING = new IndexerField( MAVEN.PACKAGING, IndexerFieldVersion.V1, "p",
          "Artifact Packaging (as keyword)", Store.NO, Index.NOT_ANALYZED );
  
      public static final IndexerField FLD_CLASSIFIER = new IndexerField( MAVEN.CLASSIFIER, IndexerFieldVersion.V1, "l",
          "Artifact classifier (as keyword)", Store.NO, Index.NOT_ANALYZED );
  
      public static final IndexerField FLD_NAME = new IndexerField( MAVEN.NAME, IndexerFieldVersion.V1, "n",
          "Artifact name (tokenized, stored)", Store.YES, Index.ANALYZED );
  
      public static final IndexerField FLD_DESCRIPTION = new IndexerField( MAVEN.DESCRIPTION, IndexerFieldVersion.V1,
          "d", "Artifact description (tokenized, stored)", Store.YES, Index.ANALYZED );
 
     public static final IndexerField FLD_LAST_MODIFIED = new IndexerField( MAVEN.LAST_MODIFIED, IndexerFieldVersion.V1,
         "m", "Artifact last modified (not indexed, stored)", Store.YES, Index.NO );
 
     public static final IndexerField FLD_SHA1 = new IndexerField( MAVEN.SHA1, IndexerFieldVersion.V1, "1",
         "Artifact SHA1 checksum (as keyword, stored)", Store.YES, Index.NOT_ANALYZED );
 
     private Locator jl = new JavadocLocator();
 
     private Locator sl = new SourcesLocator();
 
     private Locator sigl = new SignatureLocator();
 
     private Locator sha1l = new Sha1Locator();
 
     public MinimalArtifactInfoIndexCreator()
     {
         super( ID );
     }
 
     public void populateArtifactInfo( ArtifactContext ac )
     {
         File artifact = ac.getArtifact();
 
         File pom = ac.getPom();
 
         ArtifactInfo ai = ac.getArtifactInfo();
 
         if ( pom != null )
         {
             ai.lastModified = pom.lastModified();
 
             ai.fextension = "pom";
         }
 
         // TODO handle artifacts without poms
         if ( pom != null )
         {
             if ( ai.classifier != null )
             {
                 ai.sourcesExists = ArtifactAvailablility.NOT_AVAILABLE;
 
                 ai.javadocExists = ArtifactAvailablility.NOT_AVAILABLE;
             }
             else
             {
                 File sources = sl.locate( pom );
                 if ( !sources.exists() )
                 {
                     ai.sourcesExists = ArtifactAvailablility.NOT_PRESENT;
                 }
                 else
                 {
                     ai.sourcesExists = ArtifactAvailablility.PRESENT;
                 }
 
                 File javadoc = jl.locate( pom );
                 if ( !javadoc.exists() )
                 {
                     ai.javadocExists = ArtifactAvailablility.NOT_PRESENT;
                 }
                 else
                 {
                     ai.javadocExists = ArtifactAvailablility.PRESENT;
                 }
             }
         }
 
         Model model = ac.getPomModel();
 
         if ( model != null )
         {
             ai.name = model.getName();
 
             ai.description = model.getDescription();
 
             // for main artifacts (without classifier) only:
             if ( ai.classifier == null )
             {
                 // only when this is not a classified artifact
                 if ( model.getPackaging() != null )
                 {
                     // set the read value that is coming from POM
                     ai.packaging = model.getPackaging();
                 }
                 else
                 {
                     // default it, since POM is present, is read, but does not contain explicit packaging
                     // TODO: this change breaks junit tests, but not sure why is "null" expected value?
                     // ai.packaging = "jar";
                 }
             }
         }
 
         if ( "pom".equals( ai.packaging ) )
         {
             // special case, the POM _is_ the artifact
             artifact = pom;
         }
 
         if ( artifact != null )
         {
             File signature = sigl.locate( artifact );
 
             ai.signatureExists = signature.exists() ? ArtifactAvailablility.PRESENT : ArtifactAvailablility.NOT_PRESENT;
 
             File sha1 = sha1l.locate( artifact );
 
             if ( sha1.exists() )
             {
                 try
                 {
                     ai.sha1 = StringUtils.chomp( FileUtils.fileRead( sha1 ) ).trim().split( " " )[0];
                 }
                 catch ( IOException e )
                 {
                     ac.addError( e );
                 }
             }
 
             ai.lastModified = artifact.lastModified();
 
             ai.size = artifact.length();
 
             ai.fextension = getExtension( artifact, ac.getGav() );
 
             if ( ai.packaging == null )
             {
                 ai.packaging = ai.fextension;
             }
         }
     }
 
     private String getExtension( File artifact, Gav gav )
     {
         if ( gav != null && StringUtils.isNotBlank( gav.getExtension() ) )
         {
             return gav.getExtension();
         }
 
         // last resort, the extension of the file
         String artifactFileName = artifact.getName().toLowerCase();
 
         // tar.gz? and other "special" combinations
         if ( artifactFileName.endsWith( "tar.gz" ) )
         {
             return "tar.gz";
         }
         else if ( artifactFileName.equals( "tar.bz2" ) )
         {
             return "tar.bz2";
         }
 
         // get the part after the last dot
         return FileUtils.getExtension( artifactFileName );
     }
 
     public void updateDocument( ArtifactInfo ai, Document doc )
     {
         String info =
             new StringBuilder().append( ai.packaging ).append( ArtifactInfo.FS ).append(
                 Long.toString( ai.lastModified ) ).append( ArtifactInfo.FS ).append( Long.toString( ai.size ) ).append(
                 ArtifactInfo.FS ).append( ai.sourcesExists.toString() ).append( ArtifactInfo.FS ).append(
                 ai.javadocExists.toString() ).append( ArtifactInfo.FS ).append( ai.signatureExists.toString() ).append(
                 ArtifactInfo.FS ).append( ai.fextension ).toString();
 
         doc.add( FLD_INFO.toField( info ) );
 
         doc.add( FLD_GROUP_ID_KW.toField( ai.groupId ) );
         doc.add( FLD_ARTIFACT_ID_KW.toField( ai.artifactId ) );
         doc.add( FLD_VERSION_KW.toField( ai.version ) );
 
         // V3
         doc.add( FLD_GROUP_ID.toField( ai.groupId ) );
         doc.add( FLD_ARTIFACT_ID.toField( ai.artifactId ) );
         doc.add( FLD_VERSION.toField( ai.version ) );
 
         if ( ai.name != null )
         {
             doc.add( FLD_NAME.toField( ai.name ) );
         }
 
         if ( ai.description != null )
         {
             doc.add( FLD_DESCRIPTION.toField( ai.description ) );
         }
 
         if ( ai.packaging != null )
         {
             doc.add( FLD_PACKAGING.toField( ai.packaging ) );
         }
 
         if ( ai.classifier != null )
         {
             doc.add( FLD_CLASSIFIER.toField( ai.classifier ) );
         }
 
         if ( ai.sha1 != null )
         {
             doc.add( FLD_SHA1.toField( ai.sha1 ) );
         }
     }
 
     public void updateLegacyDocument( ArtifactInfo ai, Document doc )
     {
         updateDocument( ai, doc );
 
         // legacy!
         if ( ai.prefix != null )
         {
             doc.add( new Field( ArtifactInfo.PLUGIN_PREFIX, ai.prefix, Field.Store.YES, Field.Index.NOT_ANALYZED ) );
         }
 
         if ( ai.goals != null )
         {
             doc.add( new Field( ArtifactInfo.PLUGIN_GOALS, ArtifactInfo.lst2str( ai.goals ), Field.Store.YES,
                 Field.Index.NO ) );
         }
 
         doc.removeField( ArtifactInfo.GROUP_ID );
         doc.add( new Field( ArtifactInfo.GROUP_ID, ai.groupId, Field.Store.NO, Field.Index.NOT_ANALYZED ) );
     }
 
     public boolean updateArtifactInfo( Document doc, ArtifactInfo ai )
     {
         boolean res = false;
 
         String uinfo = doc.get( ArtifactInfo.UINFO );
 
         if ( uinfo != null )
         {
             String[] r = ArtifactInfo.FS_PATTERN.split( uinfo );
 
             ai.groupId = r[0];
 
             ai.artifactId = r[1];
 
             ai.version = r[2];
 
             if ( r.length > 3 )
             {
                 ai.classifier = ArtifactInfo.renvl( r[3] );
             }
 
             res = true;
         }
 
         String info = doc.get( ArtifactInfo.INFO );
 
         if ( info != null )
         {
             String[] r = ArtifactInfo.FS_PATTERN.split( info );
 
             ai.packaging = r[0];
 
             ai.lastModified = Long.parseLong( r[1] );
 
             ai.size = Long.parseLong( r[2] );
 
             ai.sourcesExists = ArtifactAvailablility.fromString( r[3] );
 
             ai.javadocExists = ArtifactAvailablility.fromString( r[4] );
 
             ai.signatureExists = ArtifactAvailablility.fromString( r[5] );
 
             if ( r.length > 6 )
             {
                 ai.fextension = r[6];
             }
             else
             {
                 if ( ai.classifier != null //
                     || "pom".equals( ai.packaging ) //
                     || "war".equals( ai.packaging ) //
                     || "ear".equals( ai.packaging ) )
                 {
                     ai.fextension = ai.packaging;
                 }
                 else
                 {
                     ai.fextension = "jar"; // best guess
                 }
             }
 
             res = true;
         }
 
         String name = doc.get( ArtifactInfo.NAME );
 
         if ( name != null )
         {
             ai.name = name;
 
             res = true;
         }
 
         String description = doc.get( ArtifactInfo.DESCRIPTION );
 
         if ( description != null )
         {
             ai.description = description;
 
             res = true;
         }
 
         // sometimes there's a pom without packaging(default to jar), but no artifact, then the value will be a "null"
         // String
         if ( "null".equals( ai.packaging ) )
         {
             ai.packaging = null;
         }
 
         String sha1 = doc.get( ArtifactInfo.SHA1 );
 
         if ( sha1 != null )
         {
             ai.sha1 = sha1;
         }
 
         return res;
 
         // artifactInfo.fname = ???
     }
 
     // ==
 
     @Override
     public String toString()
     {
         return ID;
     }
 
     public Collection<IndexerField> getIndexerFields()
     {
         return Arrays.asList( FLD_INFO, FLD_GROUP_ID_KW, FLD_GROUP_ID, FLD_ARTIFACT_ID_KW, FLD_ARTIFACT_ID,
             FLD_VERSION_KW, FLD_VERSION, FLD_PACKAGING, FLD_CLASSIFIER, FLD_NAME, FLD_DESCRIPTION, FLD_LAST_MODIFIED,
             FLD_SHA1 );
     }
 }