/* ==========================================================================

  * Copyright 2008 mkleint

  *

  * Licensed 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.

  * =========================================================================

  */

 package org.codehaus.mojo.nbm;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.logging.Log;

 import org.apache.maven.shared.dependency.graph.DependencyNode;

 import org.apache.maven.shared.dependency.graph.traversal.DependencyNodeVisitor;

 import org.codehaus.mojo.nbm.utils.ExamineManifest;

 /**

  * A dependency node visitor that collects visited nodes that are known libraries or are

  * children of known libraries

  * @author milos kleint

  */

 public class CollectLibrariesNodeVisitor

     implements DependencyNodeVisitor

 {

     /**

      * The collected list of nodes.

      */

     private final List<Artifact> nodes;

     private Map<String, Artifact> artifacts;

     private Map<Artifact, ExamineManifest> examinerCache;

     private List<String> explicitLibs;

     private final Log log;

     private MojoExecutionException throwable;

     private DependencyNode root;

     private Set<String> duplicates;

     private Set<String> conflicts;

     private Set<String> includes;

     private final boolean useOsgiDependencies;

     /**

      * Creates a dependency node visitor that collects visited nodes for further processing.

      */

     public CollectLibrariesNodeVisitor( List<String> explicitLibraries,

         List<Artifact> runtimeArtifacts, Map<Artifact, ExamineManifest> examinerCache,

         Log log, DependencyNode root, boolean useOsgiDependencies )

     {

         nodes = new ArrayList<Artifact>();

         artifacts = new HashMap<String, Artifact>();

         for ( Artifact a : runtimeArtifacts )

         {

             artifacts.put( a.getDependencyConflictId(), a );

         }

         this.examinerCache = examinerCache;

         this.explicitLibs = explicitLibraries;

         this.log = log;

         this.root = root;

         this.useOsgiDependencies = useOsgiDependencies;

         duplicates = new HashSet<String>();

         conflicts = new HashSet<String>();

         includes = new HashSet<String>();

     }

     /**

      * {@inheritDoc}

      */

     public boolean visit( DependencyNode node )

     {

         if ( throwable != null )

         {

             return false;

         }

         if ( root == node )

         {

             return true;

         }

         try

         {

             Artifact artifact = node.getArtifact();

             if ( !artifacts.containsKey( artifact.getDependencyConflictId() ) )

             {

                 //ignore non-runtime stuff..

                 return false;

             }

             // somehow the transitive artifacts in the  tree are not always resolved?

             artifact = artifacts.get( artifact.getDependencyConflictId() );

             ExamineManifest depExaminator = examinerCache.get( artifact );

             if ( depExaminator == null )

             {

                 depExaminator = new ExamineManifest( log );

                 depExaminator.setArtifactFile( artifact.getFile() );

                 depExaminator.checkFile();

                 examinerCache.put( artifact, depExaminator );

             }

             if ( AbstractNbmMojo.matchesLibrary( artifact, explicitLibs, depExaminator, log, useOsgiDependencies ) )

             {

                 if ( depExaminator.isNetBeansModule() )

                 {

                     log.warn(

                         "You are using a NetBeans Module as a Library (classpath extension): " + artifact.getId() );

                 }

                 nodes.add( artifact );

                 includes.add( artifact.getDependencyConflictId() );

                 // if a library, iterate to it's child nodes.

                 return true;

             }

         }

         catch ( MojoExecutionException mojoExecutionException )

         {

             throwable = mojoExecutionException;

         }

         //don't bother iterating to childs if the current node is not a library.

         return false;

     }

     /**

      * {@inheritDoc}

      */

     public boolean endVisit( DependencyNode node )

     {

         if ( throwable != null )

         {

             return false;

         }

         if ( node == root )

         {

             if ( nodes.size() > 0 )

             {

                 log.info( "Adding on module's Class-Path:" );

                 for ( Artifact inc : nodes )

                 {

                     log.info( "    " + inc.getId() );

                 }

             }

         }

         return true;

     }

     /**

      * Gets the list of collected dependency nodes.

      * 

      * @return the list of collected dependency nodes

      */

     public List<Artifact> getArtifacts()

         throws MojoExecutionException

     {

         if ( throwable != null )

         {

             throw throwable;

         }

         return nodes;

     }

 }