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

  * 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.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Stack;

 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 CollectModuleLibrariesNodeVisitor

     implements DependencyNodeVisitor

 {

     /**

      * The collected list of nodes.

      */

     private final Map<String, List<Artifact>> directNodes;

     private final Map<String, List<Artifact>> transitiveNodes;

     private Map<String, Artifact> artifacts;

     private Map<Artifact, ExamineManifest> examinerCache;

     private final Log log;

     private MojoExecutionException throwable;

     private DependencyNode root;

     private Stack<String> currentModule = new Stack<String>();

     private static final String LIB_ID = "!@#$%^&ROOT";

     private final boolean useOSGiDependencies;

     /**

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

      */

     public CollectModuleLibrariesNodeVisitor(

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

         Log log, DependencyNode root, boolean useOSGiDependencies )

     {

         directNodes = new HashMap<String, List<Artifact>>();

         transitiveNodes = new HashMap<String, List<Artifact>>();

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

         for ( Artifact a : runtimeArtifacts )

         {

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

         }

         this.examinerCache = examinerCache;

         this.log = log;

         this.root = root;

         this.useOSGiDependencies = useOSGiDependencies;

     }

     /**

      * {@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 ( depExaminator.isNetBeansModule() || ( useOSGiDependencies && depExaminator.isOsgiBundle() ) )

             {

                 currentModule.push( artifact.getDependencyConflictId() );

                 ArrayList<Artifact> arts = new ArrayList<Artifact>();

                 arts.add( artifact );

                 if ( currentModule.size() == 1 )

                 {

                     directNodes.put( currentModule.peek(), arts );

                 }

                 else

                 {

                     transitiveNodes.put( currentModule.peek(), arts );

                 }

                 return true;

             }

             if ( currentModule.size() > 0 )

             {

                 ////MNBMODULE-95 we are only interested in the module owned libraries

                 if ( !currentModule.peek().startsWith( LIB_ID ) &&

                         AbstractNbmMojo.matchesLibrary( artifact, Collections.<String>emptyList(), depExaminator, log, useOSGiDependencies ) )

                 {

                     if ( currentModule.size() == 1 )

                     {

                         directNodes.get( currentModule.peek() ).add( artifact );

                     }

                     else

                     {

                         transitiveNodes.get( currentModule.peek() ).add( artifact );

                     }

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

                     return true;

                 }

             }

             else

             {

                 //MNBMODULE-95 we check the non-module dependencies to see if they

                 // depend on modules/bundles. these bundles are transitive, so

                 // we add the root module as the first currentModule to keep

                 //any bundle/module underneath it as transitive

                 currentModule.push( LIB_ID + artifact.getDependencyConflictId() );

             }

         }

         catch ( MojoExecutionException mojoExecutionException )

         {

             throwable = mojoExecutionException;

         }

         return true;

     }

     /**

      * {@inheritDoc}

      */

     public boolean endVisit( DependencyNode node )

     {

         if ( throwable != null )

         {

             return false;

         }

         if ( !currentModule.empty()

             && ( currentModule.peek().equals( node.getArtifact().getDependencyConflictId() )

                             || currentModule.peek().equals( LIB_ID + node.getArtifact().getDependencyConflictId() ) ) )

         {

             currentModule.pop();

         }

         return true;

     }

     /**

      * modules declared in the project's pom

      * @return a map of module artifact lists, key is the dependencyConflictId

      * @throws org.apache.maven.plugin.MojoExecutionException

      */

     public Map<String, List<Artifact>> getDeclaredArtifacts()

         throws MojoExecutionException

     {

         if ( throwable != null )

         {

             throw throwable;

         }

         return directNodes;

     }

     /**

      * modules that were picked up transitively

      * @return a map of module artifact lists, key is the dependencyConflictId

      * @throws org.apache.maven.plugin.MojoExecutionException

      */

     public Map<String, List<Artifact>> getTransitiveArtifacts()

         throws MojoExecutionException

     {

         if ( throwable != null )

         {

             throw throwable;

         }

         return transitiveNodes;

     }

 }