package org.apache.maven.plugin.pom;

/*
 * 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.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.maven.model.Dependency;
import org.apache.maven.model.Exclusion;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;


/**
 * This goal sorts dependencies in alphabetical order.  It can also remove
 * duplicate dependency definitions.
 * 
 * @goal sort-dependencies
 */
public class SortDependenciesMojo
    extends AbstractMojo
{
    // fields -----------------------------------------------------------------

    /**
     * The current project
     * 
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;


    /**
     * Output file to write the sorted dependencies.  By default output is written to the
     * command line.
     * @parameter expression="${mpom.sort.outputFile}"
     */
    private File outputFile;
            
    /**
     * Sort the dependencies in the dependencyManagement section.
     * 
     * @parameter expression="${mpom.sort.sortDepMng}" default-value="false"
     */
    private boolean sortDepMng;
    
    /**
     * Sort the dependencies in ascending or descending alphabetical order.
     * 
     * @parameter expression="${mpom.sort.ascending}" default-value="true"
     */
    private boolean ascending;
    
    /**
     * Whether to group the dependencies by scope.
     * 
     * @parameter expression="${mpom.sort.groupByScope}" default-value="false"
     */
    private boolean groupByScope;
    
    /**
     * Whether to remove duplicate dependency definitions.
     * 
     * @parameter expression="${mpom.sort.removeDuplicates}" default-value="true"
     */
    private boolean removeDeplicates;
    
    
    // Mojo methods -----------------------------------------------------------

    /*
     * @see org.apache.maven.plugin.Mojo#execute()
     */
    public void execute() throws MojoExecutionException, MojoFailureException
    {
        List dependencies = null;
        if (sortDepMng)
        {
            dependencies = project.getDependencyManagement().getDependencies();
        }
        else
        {
            dependencies = project.getDependencies();
        }
        
        if (this.removeDeplicates)
        {
           removeDuplicates(dependencies);
        }
        
        StringBuffer depXml;
        if (groupByScope) 
        {
            List [] dependencyLists = groupByScope(dependencies);
            for ( int i = 0; i < dependencyLists.length; ++i )
            {
                this.sortDependencies(dependencyLists[i]);
            }
            
            depXml = new StringBuffer();
            dependencies.clear();
            for ( int i = 0; i < dependencyLists.length; ++i )
            {
                for ( int j = 0; j < dependencyLists[i].size(); ++j )
                {
                    dependencies.add(dependencyLists[i].get(j));
                }
            }
        }
        else 
        {
            this.sortDependencies(dependencies);
        }
        depXml = this.writeDependencyXML(dependencies);
        
        if ( outputFile != null )
        {
            if ( ! outputFile.getParentFile().exists() )
            {
                outputFile.getParentFile().mkdirs();
            }
            getLog().info( "Writing sorted dependencies to: " + this.outputFile );
            try 
            {
                FileOutputStream fos = new FileOutputStream( this.outputFile );
                PrintStream ps = new PrintStream(fos);
                ps.print( "\n" + depXml );
                ps.close();
                fos.close();
            }
            catch ( IOException ioe )
            {
                ioe.printStackTrace();
                getLog().error( ioe );
            }
        }
        else
        {
            getLog().info( "\n" + depXml );
        }
    }

    // private methods --------------------------------------------------------

    /**
     * Sorts dependencies in place.
     */
    public void sortDependencies(List dependencies)
    {        
        quicksort( dependencies, 0, dependencies.size() - 1 , ascending);
    }
    
    private List [] groupByScope(List dependencies)
    {
        List[] dependencyLists = { new ArrayList(), new ArrayList(),
                new ArrayList(), new ArrayList(), new ArrayList() };
        Iterator iter = dependencies.iterator();
        while(iter.hasNext())
        {
            Dependency dependency = (Dependency)iter.next();
            if ( dependency.getScope() == null || dependency.getScope().equals("compile") )
            {
                dependencyLists[0].add(dependency);
            }
            else if ( dependency.getScope().equals("provided") )
            {
                dependencyLists[1].add(dependency);
            }
            else if ( dependency.getScope().equals("runtime") )
            {
                dependencyLists[2].add(dependency);
            }
            else if ( dependency.getScope().equals("test") )
            {
                dependencyLists[3].add(dependency);
            }
            else if ( dependency.getScope().equals("system") )
            {
                dependencyLists[4].add(dependency);
            }
        }
        return dependencyLists;
    }

    private void removeDuplicates(List dependencies)
    {
        int i = 0;
        while( i < dependencies.size() )
        {
            if ( contains( dependencies, (Dependency)dependencies.get(i), i + 1 ) )
            {
                dependencies.remove( i );
            }
            else 
            {
                ++i;
            }
        }
    }
    
    private boolean contains(List dependencies, Dependency dependency, int index)
    {
        for( int i = index; i < dependencies.size(); ++i)
        {
            Dependency dependency2 = (Dependency)dependencies.get(i);
            if (compare(dependency, dependency2) == 0)
            {
                return true;
            }
        }
        return false;
    }
    
    private void swap( List list, int i, int j ) 
    {
        Object tmp = list.get(i);
        list.set(i, list.get(j));
        list.set(j, tmp);
    }
    
    /**
     * Quicksort a list of dependencies.
     * @param list - the list to sort
     * @param left - left end of the list
     * @param right - right end of the list
     * @param ascending - Sort ascending or descending
     */
    private void quicksort(List list, int left, int right, boolean ascending) 
    {
        int i, last;

        if (left >= right) { // do nothing if array size < 2
            return;
        }
        swap(list, left, (left + right) / 2);
        last = left;
        for (i = left + 1; i <= right; i++) 
        {
            Dependency dep1 = (Dependency)list.get(i);
            Dependency dep2 = (Dependency)list.get(left);
            if (ascending && compare(dep1, dep2) < 0) 
            {
                swap(list, ++last, i);
            } 
            else if (!ascending && compare(dep1, dep2) > 0) 
            {
                swap(list, ++last, i);
            }
        }
        swap(list, left, last);
        quicksort(list, left, last - 1, ascending);
        quicksort(list, last + 1, right, ascending);
    }


    /**
     * Compare two dependencies.  Follows the conventions of java.lang.Comparable.
     * Two dependencies are considered equal if the groupId, artifactId, version, scope,
     * and type are all the same.
     * @param dep1
     * @param dep2
     * @return
     */
    private int compare(Dependency dep1, Dependency dep2) 
    {
        if (dep1.equals(dep2))
        {
            return 0;
        }
        
        int result = dep1.getGroupId().compareTo(dep2.getGroupId());
        
        if (result != 0) return result;

        result = dep1.getArtifactId().compareTo(dep2.getArtifactId());

        if (result != 0) return result;
        
        if (dep1.getVersion() == null) 
        {
            if (dep2.getVersion() == null) 
            {
                result = 0;
            }
            else
            {
                result = -1;
            }
        }
        else
        {
            if (dep2.getVersion() == null)
            {
                result = 1;
            }
            else 
            {
                result = dep1.getVersion().compareTo(dep2.getVersion());
            }
        }

        if (result != 0) return result;
        
        if (dep1.getScope() == null) 
        {
            if (dep2.getScope() == null) 
            {
                result = 0;
            }
            else
            {
                result = -1;
            }
        }
        else
        {
            result = dep1.getScope().compareTo(dep2.getScope());
        }
        
        if (result != 0) return result;

        if (dep1.getClassifier() == null) 
        {
            if (dep2.getClassifier() == null) 
            {
                result = 0;
            }
            else
            {
                result = -1;
            }
        }
        else
        {
            if (dep2.getClassifier() == null) 
            {
                result = 1;
            }
            else
            {
                result = dep1.getClassifier().compareTo(dep2.getClassifier());
            }
        }
            
        if (result != 0) return result;
        
        if (dep1.getType() == null) {
            if (dep2.getType() == null) 
            {
                result = 0;
            }
            else
            {
                result = -1;
            }
        }
        else
        {
            if (dep2.getType() == null)
            {
                result = 1;
            }
            else
            {
                result = dep1.getType().compareTo(dep2.getType());
            }
        }
        
        return result;
    }
    
    private StringBuffer writeDependencyXML( List dependencies )
    {
        if ( !dependencies.isEmpty() )
        {
            StringWriter out = new StringWriter();
            PrettyPrintXMLWriter writer = new PrettyPrintXMLWriter( out );

            writer.startElement( "dependencies" );
            
            Iterator iter = dependencies.iterator();
            while ( iter.hasNext() )
            {
                Dependency dependency = (Dependency) iter.next();

                writer.startElement( "dependency" );
                writer.startElement( "groupId" );
                writer.writeText( dependency.getGroupId() );
                writer.endElement();
                writer.startElement( "artifactId" );
                writer.writeText( dependency.getArtifactId() );
                writer.endElement();
                writer.startElement( "version" );
                writer.writeText( dependency.getVersion());
                writer.endElement();

                if ( dependency.getScope() != null )
                {
                    writer.startElement( "scope" );
                    writer.writeText( dependency.getScope() );
                    writer.endElement();
                }
                
                if ( dependency.getClassifier() != null )
                {
                    writer.startElement( "classifier" );
                    writer.writeText( dependency.getClassifier() );
                    writer.endElement();
                }
                
                if ( dependency.getType() != null && (! dependency.getType().equals("jar")))
                {
                    writer.startElement( "type" );
                    writer.writeText( dependency.getType() );
                    writer.endElement();
                }
                
                List exclusions = dependency.getExclusions();
                if ( exclusions != null && (exclusions.size() > 0) )
                {
                    writer.startElement( "exclusions" );
                    Iterator exclIter = exclusions.iterator();
                    while(exclIter.hasNext())
                    {
                        Exclusion exclusion = (Exclusion)exclIter.next();
                        writer.startElement( "exclusion" );
                        writer.startElement("groupId");
                        writer.writeText( exclusion.getGroupId() );
                        writer.endElement();
                        writer.startElement("artifactId");
                        writer.writeText( exclusion.getArtifactId() );
                        writer.endElement();
                        writer.endElement();
                    }
                    writer.endElement();
                }
                writer.endElement();
                
            }
            writer.endElement();

            return out.getBuffer();
        }
        else
        {
            return new StringBuffer();
        }
    }
    
    /**
     * @return Returns the project.
     */
    public MavenProject getProject ()
    {
        return this.project;
    }

    /**
     * @return Returns the project.
     */
    public void setProject (MavenProject project)
    {
        this.project = project;
    }

    
}