package org.apache.maven.artifact.resolver;

 /*

  * 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.maven.artifact.Artifact;

 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;

 import org.apache.maven.artifact.versioning.ArtifactVersion;

 import org.apache.maven.artifact.versioning.OverConstrainedVersionException;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Set;

 public class ResolutionNode

 {

     private Artifact artifact;

     private List children;

     private final List parents;

     private final int depth;

     private final ResolutionNode parent;

     private final List remoteRepositories;

     private boolean active = true;

     private List trail;

     public ResolutionNode( Artifact artifact, List remoteRepositories )

     {

         this.artifact = artifact;

         this.remoteRepositories = remoteRepositories;

         depth = 0;

         parents = Collections.EMPTY_LIST;

         parent = null;

     }

     public ResolutionNode( Artifact artifact, List remoteRepositories, ResolutionNode parent )

     {

         this.artifact = artifact;

         this.remoteRepositories = remoteRepositories;

         depth = parent.depth + 1;

         parents = new ArrayList();

         parents.addAll( parent.parents );

         parents.add( parent.getKey() );

         this.parent = parent;

     }

     public void setArtifact( Artifact artifact )

     {

         this.artifact = artifact;

     }

     public Artifact getArtifact()

     {

         return artifact;

     }

     public Object getKey()

     {

         return artifact.getDependencyConflictId();

     }

     public void addDependencies( Set artifacts, List remoteRepositories, ArtifactFilter filter )

         throws CyclicDependencyException, OverConstrainedVersionException

     {

         if ( !artifacts.isEmpty() )

         {

             children = new ArrayList( artifacts.size() );

             for ( Iterator i = artifacts.iterator(); i.hasNext(); )

             {

                 Artifact a = (Artifact) i.next();

                 if ( parents.contains( a.getDependencyConflictId() ) )

                 {

                     a.setDependencyTrail( getDependencyTrail() );

                     throw new CyclicDependencyException( "A dependency has introduced a cycle", a );

                 }

                 children.add( new ResolutionNode( a, remoteRepositories, this ) );

             }

         }

         else

         {

             children = Collections.EMPTY_LIST;

         }

         trail = null;

     }

     /**

      * @return {@link List} < {@link String} > with artifact ids

      * @throws OverConstrainedVersionException

      */

     public List getDependencyTrail()

         throws OverConstrainedVersionException

     {

         List trial = getTrail();

         List ret = new ArrayList( trial.size() );

         for ( Iterator i = trial.iterator(); i.hasNext(); )

         {

             Artifact artifact = (Artifact) i.next();

             ret.add( artifact.getId() );

         }

         return ret;

     }

     private List getTrail()

         throws OverConstrainedVersionException

     {

         if ( trail == null )

         {

             List ids = new LinkedList();

             ResolutionNode node = this;

             while ( node != null )

             {

                 Artifact artifact = node.getArtifact();

                 if ( artifact.getVersion() == null )

                 {

                     // set the recommended version

                     ArtifactVersion selected = artifact.getSelectedVersion();

                     //MNG-2123: null is a valid response to getSelectedVersion, don't

                     //assume it won't ever be.

                     if (selected != null)

                     {

                         artifact.selectVersion( selected.toString() );

                     }

                     else

                     {

                         throw new OverConstrainedVersionException("Unable to get a selected Version for "+ artifact.getArtifactId(),artifact);

                     }

                 }

                 ids.add( 0, artifact );

                 node = node.parent;

             }

             trail = ids;

         }

         return trail;

     }

     public boolean isResolved()

     {

         return children != null;

     }

     public boolean isChildOfRootNode()

     {

         return parent != null && parent.parent == null;

     }

     public Iterator getChildrenIterator()

     {

         return children.iterator();

     }

     public int getDepth()

     {

         return depth;

     }

     public List getRemoteRepositories()

     {

         return remoteRepositories;

     }

     public boolean isActive()

     {

         return active;

     }

     public void enable()

     {

         active = true;

         // TODO: if it was null, we really need to go find them now... or is this taken care of by the ordering?

         if ( children != null )

         {

             for ( Iterator i = children.iterator(); i.hasNext(); )

             {

                 ResolutionNode node = (ResolutionNode) i.next();

                 node.enable();

             }

         }

     }

     public void disable()

     {

         active = false;

         if ( children != null )

         {

             for ( Iterator i = children.iterator(); i.hasNext(); )

             {

                 ResolutionNode node = (ResolutionNode) i.next();

                 node.disable();

             }

         }

     }

     public boolean filterTrail( ArtifactFilter filter )

         throws OverConstrainedVersionException

     {

         boolean success = true;

         if ( filter != null )

         {

             for ( Iterator i = getTrail().iterator(); i.hasNext() && success; )

             {

                 Artifact artifact = (Artifact) i.next();

                 if ( !filter.include( artifact ) )

                 {

                     success = false;

                 }

             }

         }

         return success;

     }

     public String toString()

     {

         return artifact.toString() + " (" + depth + "; " + ( active ? "enabled" : "disabled" ) + ")";

     }

 }